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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
generic_serial.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：26k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

generic_serial.c：源码内容
  1. /*
  2.  *  generic_serial.c
  3.  *
  4.  *  Copyright (C) 1998/1999 R.E.Wolff@BitWizard.nl
  5.  *
  6.  *  written for the SX serial driver.
  7.  *     Contains the code that should be shared over all the serial drivers.
  8.  *
  9.  *  Credit for the idea to do it this way might go to Alan Cox. 
  10.  *
  11.  *
  12.  *  Version 0.1 -- December, 1998. Initial version.
  13.  *  Version 0.2 -- March, 1999.    Some more routines. Bugfixes. Etc.
  14.  *  Version 0.5 -- August, 1999.   Some more fixes. Reformat for Linus.
  15.  *
  16.  *  BitWizard is actively maintaining this file. We sometimes find
  17.  *  that someone submitted changes to this file. We really appreciate
  18.  *  your help, but please submit changes through us. We're doing our
  19.  *  best to be responsive.  -- REW
  20.  * */
  22. #include <linux/module.h>
  23. #include <linux/kernel.h>
  24. #include <linux/tty.h>
  25. #include <linux/serial.h>
  26. #include <linux/mm.h>
  27. #include <linux/generic_serial.h>
  28. #include <asm/semaphore.h>
  29. #include <asm/uaccess.h>
  31. #define DEBUG 
  33. static char *                  tmp_buf; 
  34. static DECLARE_MUTEX(tmp_buf_sem);
  36. static int gs_debug;
  38. #ifdef DEBUG
  39. #define gs_dprintk(f, str...) if (gs_debug & f) printk (str)
  40. #else
  41. #define gs_dprintk(f, str...) /* nothing */
  42. #endif
  44. #define func_enter() gs_dprintk (GS_DEBUG_FLOW, "gs: enter %sn", __FUNCTION__)
  45. #define func_exit()  gs_dprintk (GS_DEBUG_FLOW, "gs: exit  %sn", __FUNCTION__)
  47. #if NEW_WRITE_LOCKING
  48. #define DECL      /* Nothing */
  49. #define LOCKIT    down (& port->port_write_sem);
  50. #define RELEASEIT up (&port->port_write_sem);
  51. #else
  52. #define DECL      unsigned long flags;
  53. #define LOCKIT    save_flags (flags);cli ()
  54. #define RELEASEIT restore_flags (flags)
  55. #endif
  57. #define RS_EVENT_WRITE_WAKEUP 1
  59. MODULE_PARM(gs_debug, "i");
  62. void gs_put_char(struct tty_struct * tty, unsigned char ch)
  63. {
  64. struct gs_port *port;
  65. DECL
  67. func_enter (); 
  69. if (!tty) return;
  71. port = tty->driver_data;
  73. if (!port) return;
  75. if (! (port->flags & ASYNC_INITIALIZED)) return;
  77. /* Take a lock on the serial tranmit buffer! */
  78. LOCKIT;
  80. if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  81. /* Sorry, buffer is full, drop character. Update statistics???? -- REW */
  82. RELEASEIT;
  83. return;
  84. }
  86. port->xmit_buf[port->xmit_head++] = ch;
  87. port->xmit_head &= SERIAL_XMIT_SIZE - 1;
  88. port->xmit_cnt++;  /* Characters in buffer */
  90. RELEASEIT;
  91. func_exit ();
  92. }
  95. #ifdef NEW_WRITE_LOCKING
  97. /*
  98. > Problems to take into account are:
  99. >       -1- Interrupts that empty part of the buffer.
  100. >       -2- page faults on the access to userspace. 
  101. >       -3- Other processes that are also trying to do a "write". 
  102. */
  104. int gs_write(struct tty_struct * tty, int from_user, 
  105.                     const unsigned char *buf, int count)
  106. {
  107. struct gs_port *port;
  108. int c, total = 0;
  109. int t;
  111. func_enter ();
  113. if (!tty) return 0;
  115. port = tty->driver;
  117. if (!port) return 0;
  119. if (! (port->flags & ASYNC_INITIALIZED))
  120. return 0;
  122. /* get exclusive "write" access to this port (problem 3) */
  123. /* This is not a spinlock because we can have a disk access (page 
  124.  fault) in copy_from_user */
  125. down (& port->port_write_sem);
  127. while (1) {
  129. c = count;
  130.  
  131. /* This is safe because we "OWN" the "head". Noone else can 
  132.    change the "head": we own the port_write_sem. */
  133. /* Don't overrun the end of the buffer */
  134. t = SERIAL_XMIT_SIZE - port->xmit_head;
  135. if (t < c) c = t;
  136.  
  137. /* This is safe because the xmit_cnt can only decrease. This 
  138.    would increase "t", so we might copy too little chars. */
  139. /* Don't copy past the "head" of the buffer */
  140. t = SERIAL_XMIT_SIZE - 1 - port->xmit_cnt;
  141. if (t < c) c = t;
  142.  
  143. /* Can't copy more? break out! */
  144. if (c <= 0) break;
  145. if (from_user)
  146.                        if (copy_from_user (port->xmit_buf + port->xmit_head, 
  147.                                            buf, c)) {
  148.                                up (& port->port_write_sem);
  149.                                return -EFAULT;
  150.                        }
  152. else
  153. memcpy         (port->xmit_buf + port->xmit_head, buf, c);
  155. port -> xmit_cnt += c;
  156. port -> xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE -1);
  157. buf += c;
  158. count -= c;
  159. total += c;
  160. }
  161. up (& port->port_write_sem);
  163. gs_dprintk (GS_DEBUG_WRITE, "write: interrupts are %sn", 
  164.             (port->flags & GS_TX_INTEN)?"enabled": "disabled"); 
  166. if (port->xmit_cnt && 
  167.     !tty->stopped && 
  168.     !tty->hw_stopped &&
  169.     !(port->flags & GS_TX_INTEN)) {
  170. port->flags |= GS_TX_INTEN;
  171. port->rd->enable_tx_interrupts (port);
  172. }
  173. func_exit ();
  174. return total;
  175. }
  176. #else
  177. /*
  178. > Problems to take into account are:
  179. >       -1- Interrupts that empty part of the buffer.
  180. >       -2- page faults on the access to userspace. 
  181. >       -3- Other processes that are also trying to do a "write". 
  182. */
  184. int gs_write(struct tty_struct * tty, int from_user, 
  185.                     const unsigned char *buf, int count)
  186. {
  187. struct gs_port *port;
  188. int c, total = 0;
  189. int t;
  190. unsigned long flags;
  192. func_enter ();
  194. /* The standard serial driver returns 0 in this case. 
  195.    That sounds to me as "No error, I just didn't get to writing any
  196.    bytes. Feel free to try again." 
  197.    The "official" way to write n bytes from buf is:
  199.  for (nwritten = 0;nwritten < n;nwritten += rv) {
  200.  rv = write (fd, buf+nwritten, n-nwritten);
  201.  if (rv < 0) break; // Error: bail out. //
  202.  } 
  204.    which will loop endlessly in this case. The manual page for write
  205.    agrees with me. In practise almost everybody writes 
  206.    "write (fd, buf,n);" but some people might have had to deal with 
  207.    incomplete writes in the past and correctly implemented it by now... 
  208.  */
  210. if (!tty) return -EIO;
  212. port = tty->driver_data;
  213. if (!port || !port->xmit_buf || !tmp_buf)
  214. return -EIO;
  216. save_flags(flags);
  217. if (from_user) {
  218. down(&tmp_buf_sem);
  219. while (1) {
  220. c = count;
  222. /* Note: This part can be done without
  223.  * interrupt routine protection since
  224.  * the interrupt routines may only modify
  225.  * shared variables in safe ways, in the worst
  226.  * case causing us to loop twice in the code
  227.  * below. See comments below. */ 
  229. /* Don't overrun the end of the buffer */
  230. t = SERIAL_XMIT_SIZE - port->xmit_head;
  231. if (t < c) c = t;
  232.  
  233. /* This is safe because the xmit_cnt can only decrease. This 
  234.    would increase "t", so we might copy too little chars. */
  235. /* Don't copy past the "head" of the buffer */
  236. t = SERIAL_XMIT_SIZE - 1 - port->xmit_cnt;
  237. if (t < c) c = t;  
  239. /* Can't copy more? break out! */
  240. if (c <= 0) break;
  242. c -= copy_from_user(tmp_buf, buf, c);
  243. if (!c) {
  244. if (!total)
  245. total = -EFAULT;
  246. break;
  247. }
  248. cli();
  249. t = SERIAL_XMIT_SIZE - port->xmit_head;
  250. if (t < c) c = t;
  251. t = SERIAL_XMIT_SIZE - 1 - port->xmit_cnt;
  252. if (t < c) c = t;
  254. memcpy(port->xmit_buf + port->xmit_head, tmp_buf, c);
  255. port->xmit_head = ((port->xmit_head + c) &
  256.                    (SERIAL_XMIT_SIZE-1));
  257. port->xmit_cnt += c;
  258. restore_flags(flags);
  259. buf += c;
  260. count -= c;
  261. total += c;
  262. }
  263. up(&tmp_buf_sem);
  264. } else {
  265. while (1) {
  266. cli();
  267. c = count;
  269. /* This is safe because we "OWN" the "head". Noone else can 
  270.    change the "head": we own the port_write_sem. */
  271. /* Don't overrun the end of the buffer */
  272. t = SERIAL_XMIT_SIZE - port->xmit_head;
  273. if (t < c) c = t;
  274.  
  275. /* This is safe because the xmit_cnt can only decrease. This 
  276.    would increase "t", so we might copy too little chars. */
  277. /* Don't copy past the "head" of the buffer */
  278. t = SERIAL_XMIT_SIZE - 1 - port->xmit_cnt;
  279. if (t < c) c = t;
  280.  
  281. /* Can't copy more? break out! */
  282. if (c <= 0) {
  283. restore_flags(flags);
  284. break;
  285. }
  286. memcpy(port->xmit_buf + port->xmit_head, buf, c);
  287. port->xmit_head = ((port->xmit_head + c) &
  288.                    (SERIAL_XMIT_SIZE-1));
  289. port->xmit_cnt += c;
  290. restore_flags(flags);
  291. buf += c;
  292. count -= c;
  293. total += c;
  294. }
  295. }
  297. if (port->xmit_cnt && 
  298.     !tty->stopped && 
  299.     !tty->hw_stopped &&
  300.     !(port->flags & GS_TX_INTEN)) {
  301. port->flags |= GS_TX_INTEN;
  302. port->rd->enable_tx_interrupts (port);
  303. }
  304. func_exit ();
  305. return total;
  306. }
  308. #endif
  312. int gs_write_room(struct tty_struct * tty)
  313. {
  314. struct gs_port *port = tty->driver_data;
  315. int ret;
  317. func_enter ();
  318. ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
  319. if (ret < 0)
  320. ret = 0;
  321. func_exit ();
  322. return ret;
  323. }
  326. int gs_chars_in_buffer(struct tty_struct *tty)
  327. {
  328. struct gs_port *port = tty->driver_data;
  329. func_enter ();
  331. func_exit ();
  332. return port->xmit_cnt;
  333. }
  336. int gs_real_chars_in_buffer(struct tty_struct *tty)
  337. {
  338. struct gs_port *port;
  339. func_enter ();
  341. if (!tty) return 0;
  342. port = tty->driver_data;
  344. if (!port->rd) return 0;
  345. if (!port->rd->chars_in_buffer) return 0;
  347. func_exit ();
  348. return port->xmit_cnt + port->rd->chars_in_buffer (port);
  349. }
  352. static int gs_wait_tx_flushed (void * ptr, int timeout) 
  353. {
  354. struct gs_port *port = ptr;
  355. long end_jiffies;
  356. int jiffies_to_transmit, charsleft = 0, rv = 0;
  357. int rcib;
  359. func_enter();
  361. gs_dprintk (GS_DEBUG_FLUSH, "port=%p.n", port);
  362. if (port) {
  363. gs_dprintk (GS_DEBUG_FLUSH, "xmit_cnt=%x, xmit_buf=%p, tty=%p.n", 
  364. port->xmit_cnt, port->xmit_buf, port->tty);
  365. }
  367. if (!port || port->xmit_cnt < 0 || !port->xmit_buf) {
  368. gs_dprintk (GS_DEBUG_FLUSH, "ERROR: !port, !port->xmit_buf or prot->xmit_cnt < 0.n");
  369. func_exit();
  370. return -EINVAL;  /* This is an error which we don't know how to handle. */
  371. }
  373. rcib = gs_real_chars_in_buffer(port->tty);
  375. if(rcib <= 0) {
  376. gs_dprintk (GS_DEBUG_FLUSH, "nothing to wait for.n");
  377. func_exit();
  378. return rv;
  379. }
  380. /* stop trying: now + twice the time it would normally take +  seconds */
  381. if (timeout == 0) timeout = MAX_SCHEDULE_TIMEOUT;
  382. end_jiffies  = jiffies; 
  383. if (timeout !=  MAX_SCHEDULE_TIMEOUT)
  384. end_jiffies += port->baud?(2 * rcib * 10 * HZ / port->baud):0;
  385. end_jiffies += timeout;
  387. gs_dprintk (GS_DEBUG_FLUSH, "now=%lx, end=%lx (%ld).n", 
  388.     jiffies, end_jiffies, end_jiffies-jiffies); 
  390. /* the expression is actually jiffies < end_jiffies, but that won't
  391.    work around the wraparound. Tricky eh? */
  392. while ((charsleft = gs_real_chars_in_buffer (port->tty)) &&
  393.         time_after (end_jiffies, jiffies)) {
  394. /* Units check: 
  395.    chars * (bits/char) * (jiffies /sec) / (bits/sec) = jiffies!
  396.    check! */
  398. charsleft += 16; /* Allow 16 chars more to be transmitted ... */
  399. jiffies_to_transmit = port->baud?(1 + charsleft * 10 * HZ / port->baud):0;
  400. /*                                ^^^ Round up.... */
  401. if (jiffies_to_transmit <= 0) jiffies_to_transmit = 1;
  403. gs_dprintk (GS_DEBUG_FLUSH, "Expect to finish in %d jiffies "
  404.     "(%d chars).n", jiffies_to_transmit, charsleft); 
  406. set_current_state (TASK_INTERRUPTIBLE);
  407. schedule_timeout(jiffies_to_transmit);
  408. if (signal_pending (current)) {
  409. gs_dprintk (GS_DEBUG_FLUSH, "Signal pending. Bombing out: "); 
  410. rv = -EINTR;
  411. break;
  412. }
  413. }
  415. gs_dprintk (GS_DEBUG_FLUSH, "charsleft = %d.n", charsleft); 
  416. set_current_state (TASK_RUNNING);
  418. func_exit();
  419. return rv;
  420. }
  424. void gs_flush_buffer(struct tty_struct *tty)
  425. {
  426. struct gs_port *port;
  427. unsigned long flags;
  429. func_enter ();
  431. if (!tty) return;
  433. port = tty->driver_data;
  435. if (!port) return;
  437. /* XXX Would the write semaphore do? */
  438. save_flags(flags); cli();
  439. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  440. restore_flags(flags);
  442. wake_up_interruptible(&tty->write_wait);
  443. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  444.     tty->ldisc.write_wakeup)
  445. (tty->ldisc.write_wakeup)(tty);
  446. func_exit ();
  447. }
  450. void gs_flush_chars(struct tty_struct * tty)
  451. {
  452. struct gs_port *port;
  454. func_enter ();
  456. if (!tty) return;
  458. port = tty->driver_data;
  460. if (!port) return;
  462. if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  463.     !port->xmit_buf) {
  464. func_exit ();
  465. return;
  466. }
  468. /* Beats me -- REW */
  469. port->flags |= GS_TX_INTEN;
  470. port->rd->enable_tx_interrupts (port);
  471. func_exit ();
  472. }
  475. void gs_stop(struct tty_struct * tty)
  476. {
  477. struct gs_port *port;
  479. func_enter ();
  481. if (!tty) return;
  483. port = tty->driver_data;
  485. if (!port) return;
  487. if (port->xmit_cnt && 
  488.     port->xmit_buf && 
  489.     (port->flags & GS_TX_INTEN) ) {
  490. port->flags &= ~GS_TX_INTEN;
  491. port->rd->disable_tx_interrupts (port);
  492. }
  493. func_exit ();
  494. }
  497. void gs_start(struct tty_struct * tty)
  498. {
  499. struct gs_port *port;
  501. if (!tty) return;
  503. port = tty->driver_data;
  505. if (!port) return;
  507. if (port->xmit_cnt && 
  508.     port->xmit_buf && 
  509.     !(port->flags & GS_TX_INTEN) ) {
  510. port->flags |= GS_TX_INTEN;
  511. port->rd->enable_tx_interrupts (port);
  512. }
  513. func_exit ();
  514. }
  517. void gs_shutdown_port (struct gs_port *port)
  518. {
  519. unsigned long flags;
  521. func_enter();
  523. if (!port) return;
  525. if (!(port->flags & ASYNC_INITIALIZED))
  526. return;
  528. save_flags (flags);
  529. cli ();
  531. if (port->xmit_buf) {
  532. free_page((unsigned long) port->xmit_buf);
  533. port->xmit_buf = 0;
  534. }
  536. if (port->tty)
  537. set_bit(TTY_IO_ERROR, &port->tty->flags);
  539. port->rd->shutdown_port (port);
  541. port->flags &= ~ASYNC_INITIALIZED;
  542. restore_flags (flags);
  544. func_exit();
  545. }
  548. void gs_hangup(struct tty_struct *tty)
  549. {
  550. struct gs_port   *port;
  552. func_enter ();
  554. if (!tty) return;
  556. port = tty->driver_data;
  557. tty = port->tty;
  558. if (!tty) 
  559. return;
  561. gs_shutdown_port (port);
  562. port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE |GS_ACTIVE);
  563. port->tty = NULL;
  564. port->count = 0;
  566. wake_up_interruptible(&port->open_wait);
  567. func_exit ();
  568. }
  571. void gs_do_softint(void *private_)
  572. {
  573. struct gs_port *port = private_;
  574. struct tty_struct *tty;
  576. func_enter ();
  578. if (!port) return;
  580. tty = port->tty;
  582. if (!tty) return;
  584. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
  585. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  586.     tty->ldisc.write_wakeup)
  587. (tty->ldisc.write_wakeup)(tty);
  588. wake_up_interruptible(&tty->write_wait);
  589. }
  590. func_exit ();
  591. }
  594. int gs_block_til_ready(void *port_, struct file * filp)
  595. {
  596. struct gs_port *port = port_;
  597. DECLARE_WAITQUEUE(wait, current);
  598. int    retval;
  599. int    do_clocal = 0;
  600. int    CD;
  601. struct tty_struct *tty;
  602. unsigned long flags;
  604. func_enter ();
  606. if (!port) return 0;
  608. tty = port->tty;
  610. if (!tty) return 0;
  612. gs_dprintk (GS_DEBUG_BTR, "Entering gs_block_till_ready.n"); 
  613. /*
  614.  * If the device is in the middle of being closed, then block
  615.  * until it's done, and then try again.
  616.  */
  617. if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
  618. interruptible_sleep_on(&port->close_wait);
  619. if (port->flags & ASYNC_HUP_NOTIFY)
  620. return -EAGAIN;
  621. else
  622. return -ERESTARTSYS;
  623. }
  625. gs_dprintk (GS_DEBUG_BTR, "after hung upn"); 
  627. /*
  628.  * If this is a callout device, then just make sure the normal
  629.  * device isn't being used.
  630.  */
  631. if (tty->driver.subtype == GS_TYPE_CALLOUT) {
  632. if (port->flags & ASYNC_NORMAL_ACTIVE)
  633. return -EBUSY;
  634. if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
  635.     (port->flags & ASYNC_SESSION_LOCKOUT) &&
  636.     (port->session != current->session))
  637. return -EBUSY;
  638. if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
  639.     (port->flags & ASYNC_PGRP_LOCKOUT) &&
  640.     (port->pgrp != current->pgrp))
  641. return -EBUSY;
  642. port->flags |= ASYNC_CALLOUT_ACTIVE;
  643. return 0;
  644. }
  646. gs_dprintk (GS_DEBUG_BTR, "after subtypen");
  648. /*
  649.  * If non-blocking mode is set, or the port is not enabled,
  650.  * then make the check up front and then exit.
  651.  */
  652. if ((filp->f_flags & O_NONBLOCK) ||
  653.     (tty->flags & (1 << TTY_IO_ERROR))) {
  654. if (port->flags & ASYNC_CALLOUT_ACTIVE)
  655. return -EBUSY;
  656. port->flags |= ASYNC_NORMAL_ACTIVE;
  657. return 0;
  658. }
  660. gs_dprintk (GS_DEBUG_BTR, "after nonblockn"); 
  661.  
  662. if (port->flags & ASYNC_CALLOUT_ACTIVE) {
  663. if (port->normal_termios.c_cflag & CLOCAL) 
  664. do_clocal = 1;
  665. } else {
  666. if (C_CLOCAL(tty))
  667. do_clocal = 1;
  668. }
  670. /*
  671.  * Block waiting for the carrier detect and the line to become
  672.  * free (i.e., not in use by the callout).  While we are in
  673.  * this loop, port->count is dropped by one, so that
  674.  * rs_close() knows when to free things.  We restore it upon
  675.  * exit, either normal or abnormal.
  676.  */
  677. retval = 0;
  679. add_wait_queue(&port->open_wait, &wait);
  681. gs_dprintk (GS_DEBUG_BTR, "after add waitq.n"); 
  682. save_flags(flags);
  683. cli();
  684. if (!tty_hung_up_p(filp))
  685. port->count--;
  686. restore_flags(flags);
  687. port->blocked_open++;
  688. while (1) {
  689. CD = port->rd->get_CD (port);
  690. gs_dprintk (GS_DEBUG_BTR, "CD is now %d.n", CD);
  691. set_current_state (TASK_INTERRUPTIBLE);
  692. if (tty_hung_up_p(filp) ||
  693.     !(port->flags & ASYNC_INITIALIZED)) {
  694. if (port->flags & ASYNC_HUP_NOTIFY)
  695. retval = -EAGAIN;
  696. else
  697. retval = -ERESTARTSYS;
  698. break;
  699. }
  700. if (!(port->flags & ASYNC_CALLOUT_ACTIVE) &&
  701.     !(port->flags & ASYNC_CLOSING) &&
  702.     (do_clocal || CD))
  703. break;
  704. gs_dprintk (GS_DEBUG_BTR, "signal_pending is now: %d (%lx)n", 
  705. (int)signal_pending (current), *(long*)(&current->blocked)); 
  706. if (signal_pending(current)) {
  707. retval = -ERESTARTSYS;
  708. break;
  709. }
  710. schedule();
  711. }
  712. gs_dprintk (GS_DEBUG_BTR, "Got out of the loop. (%d)n",
  713.     port->blocked_open);
  714. set_current_state (TASK_RUNNING);
  715. remove_wait_queue(&port->open_wait, &wait);
  716. if (!tty_hung_up_p(filp))
  717. port->count++;
  718. port->blocked_open--;
  719. if (retval)
  720. return retval;
  722. port->flags |= ASYNC_NORMAL_ACTIVE;
  723. func_exit ();
  724. return 0;
  725. }  
  728. void gs_close(struct tty_struct * tty, struct file * filp)
  729. {
  730. unsigned long flags;
  731. struct gs_port *port;
  733. func_enter ();
  735. if (!tty) return;
  737. port = (struct gs_port *) tty->driver_data;
  739. if (!port) return;
  741. if (!port->tty) {
  742. /* This seems to happen when this is called from vhangup. */
  743. gs_dprintk (GS_DEBUG_CLOSE, "gs: Odd: port->tty is NULLn");
  744. port->tty = tty;
  745. }
  747. save_flags(flags); cli();
  749. if (tty_hung_up_p(filp)) {
  750. restore_flags(flags);
  751. port->rd->hungup (port);
  752. func_exit ();
  753. return;
  754. }
  756. if ((tty->count == 1) && (port->count != 1)) {
  757. printk(KERN_ERR "gs: gs_close: bad port count;"
  758.        " tty->count is 1, port count is %dn", port->count);
  759. port->count = 1;
  760. }
  761. if (--port->count < 0) {
  762. printk(KERN_ERR "gs: gs_close: bad port count: %dn", port->count);
  763. port->count = 0;
  764. }
  765. if (port->count) {
  766. gs_dprintk(GS_DEBUG_CLOSE, "gs_close: count: %dn", port->count);
  767. restore_flags(flags);
  768. func_exit ();
  769. return;
  770. }
  771. port->flags |= ASYNC_CLOSING;
  773. /*
  774.  * Save the termios structure, since this port may have
  775.  * separate termios for callout and dialin.
  776.  */
  777. if (port->flags & ASYNC_NORMAL_ACTIVE)
  778. port->normal_termios = *tty->termios;
  779. if (port->flags & ASYNC_CALLOUT_ACTIVE)
  780. port->callout_termios = *tty->termios;
  781. /*
  782.  * Now we wait for the transmit buffer to clear; and we notify 
  783.  * the line discipline to only process XON/XOFF characters.
  784.  */
  785. tty->closing = 1;
  786. /* if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  787.    tty_wait_until_sent(tty, port->closing_wait); */
  789. /*
  790.  * At this point we stop accepting input.  To do this, we
  791.  * disable the receive line status interrupts, and tell the
  792.  * interrupt driver to stop checking the data ready bit in the
  793.  * line status register.
  794.  */
  796. port->rd->disable_rx_interrupts (port);
  798. /* close has no way of returning "EINTR", so discard return value */
  799. if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  800. gs_wait_tx_flushed (port, port->closing_wait); 
  802. port->flags &= ~GS_ACTIVE;
  804. if (tty->driver.flush_buffer)
  805. tty->driver.flush_buffer(tty);
  806. if (tty->ldisc.flush_buffer)
  807. tty->ldisc.flush_buffer(tty);
  808. tty->closing = 0;
  810. port->event = 0;
  811. port->rd->close (port);
  812. port->rd->shutdown_port (port);
  813. port->tty = 0;
  815. if (port->blocked_open) {
  816. if (port->close_delay) {
  817. set_current_state (TASK_INTERRUPTIBLE);
  818. schedule_timeout(port->close_delay);
  819. }
  820. wake_up_interruptible(&port->open_wait);
  821. }
  822. port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  823.                  ASYNC_CLOSING | ASYNC_INITIALIZED);
  824. wake_up_interruptible(&port->close_wait);
  826. restore_flags(flags);
  827. func_exit ();
  828. }
  831. static unsigned int     gs_baudrates[] = {
  832.   0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  833.   9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
  834. };
  837. void gs_set_termios (struct tty_struct * tty, 
  838.                      struct termios * old_termios)
  839. {
  840. struct gs_port *port;
  841. int baudrate, tmp, rv;
  842. struct termios *tiosp;
  844. func_enter();
  846. if (!tty) return;
  848. port = tty->driver_data;
  850. if (!port) return;
  852. tiosp = tty->termios;
  854. if (gs_debug & GS_DEBUG_TERMIOS) {
  855. gs_dprintk (GS_DEBUG_TERMIOS, "termios structure (%p):n", tiosp);
  856. }
  858. #if 0
  859. /* This is an optimization that is only allowed for dumb cards */
  860. /* Smart cards require knowledge of iflags and oflags too: that 
  861.    might change hardware cooking mode.... */
  862. #endif
  863. if (old_termios) {
  864. if(   (tiosp->c_iflag == old_termios->c_iflag)
  865.    && (tiosp->c_oflag == old_termios->c_oflag)
  866.    && (tiosp->c_cflag == old_termios->c_cflag)
  867.    && (tiosp->c_lflag == old_termios->c_lflag)
  868.    && (tiosp->c_line  == old_termios->c_line)
  869.    && (memcmp(tiosp->c_cc, old_termios->c_cc, NCC) == 0)) {
  870. gs_dprintk(GS_DEBUG_TERMIOS, "gs_set_termios: optimized awayn");
  871. return /* 0 */;
  872. }
  873. } else 
  874. gs_dprintk(GS_DEBUG_TERMIOS, "gs_set_termios: no old_termios: "
  875.            "no optimizationn");
  877. if(old_termios && (gs_debug & GS_DEBUG_TERMIOS)) {
  878. if(tiosp->c_iflag != old_termios->c_iflag)  printk("c_iflag changedn");
  879. if(tiosp->c_oflag != old_termios->c_oflag)  printk("c_oflag changedn");
  880. if(tiosp->c_cflag != old_termios->c_cflag)  printk("c_cflag changedn");
  881. if(tiosp->c_lflag != old_termios->c_lflag)  printk("c_lflag changedn");
  882. if(tiosp->c_line  != old_termios->c_line)   printk("c_line changedn");
  883. if(!memcmp(tiosp->c_cc, old_termios->c_cc, NCC)) printk("c_cc changedn");
  884. }
  886. baudrate = tiosp->c_cflag & CBAUD;
  887. if (baudrate & CBAUDEX) {
  888. baudrate &= ~CBAUDEX;
  889. if ((baudrate < 1) || (baudrate > 4))
  890. tiosp->c_cflag &= ~CBAUDEX;
  891. else
  892. baudrate += 15;
  893. }
  895. baudrate = gs_baudrates[baudrate];
  896. if ((tiosp->c_cflag & CBAUD) == B38400) {
  897. if (     (port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  898. baudrate = 57600;
  899. else if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  900. baudrate = 115200;
  901. else if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
  902. baudrate = 230400;
  903. else if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
  904. baudrate = 460800;
  905. else if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
  906. baudrate = (port->baud_base / port->custom_divisor);
  907. }
  909. /* I recommend using THIS instead of the mess in termios (and
  910.    duplicating the above code). Next we should create a clean
  911.    interface towards this variable. If your card supports arbitrary
  912.    baud rates, (e.g. CD1400 or 16550 based cards) then everything
  913.    will be very easy..... */
  914. port->baud = baudrate;
  916. /* Two timer ticks seems enough to wakeup something like SLIP driver */
  917. /* Baudrate/10 is cps. Divide by HZ to get chars per tick. */
  918. tmp = (baudrate / 10 / HZ) * 2;  
  920. if (tmp <                 0) tmp = 0;
  921. if (tmp >= SERIAL_XMIT_SIZE) tmp = SERIAL_XMIT_SIZE-1;
  923. port->wakeup_chars = tmp;
  925. /* We should really wait for the characters to be all sent before
  926.    changing the settings. -- CAL */
  927. rv = gs_wait_tx_flushed (port, MAX_SCHEDULE_TIMEOUT);
  928. if (rv < 0) return /* rv */;
  930. rv = port->rd->set_real_termios(port);
  931. if (rv < 0) return /* rv */;
  933. if ((!old_termios || 
  934.      (old_termios->c_cflag & CRTSCTS)) &&
  935.     !(      tiosp->c_cflag & CRTSCTS)) {
  936. tty->stopped = 0;
  937. gs_start(tty);
  938. }
  940. #ifdef tytso_patch_94Nov25_1726
  941. /* This "makes sense", Why is it commented out? */
  943. if (!(old_termios->c_cflag & CLOCAL) &&
  944.     (tty->termios->c_cflag & CLOCAL))
  945. wake_up_interruptible(&info->open_wait);
  946. #endif
  948. func_exit();
  949. return /* 0 */;
  950. }
  954. /* Must be called with interrupts enabled */
  955. int gs_init_port(struct gs_port *port)
  956. {
  957. unsigned long flags;
  958. unsigned long page;
  960. save_flags (flags);
  961. if (!tmp_buf) {
  962. page = get_free_page(GFP_KERNEL);
  964. cli (); /* Don't expect this to make a difference. */ 
  965. if (tmp_buf)
  966. free_page(page);
  967. else
  968. tmp_buf = (unsigned char *) page;
  969. restore_flags (flags);
  971. if (!tmp_buf) {
  972. return -ENOMEM;
  973. }
  974. }
  976. if (port->flags & ASYNC_INITIALIZED)
  977. return 0;
  979. if (!port->xmit_buf) {
  980. /* We may sleep in get_free_page() */
  981. unsigned long tmp;
  983. tmp = get_free_page(GFP_KERNEL);
  985. /* Spinlock? */
  986. cli ();
  987. if (port->xmit_buf) 
  988. free_page (tmp);
  989. else
  990. port->xmit_buf = (unsigned char *) tmp;
  991. restore_flags (flags);
  993. if (!port->xmit_buf)
  994. return -ENOMEM;
  995. }
  997. cli();
  999. if (port->tty) 
  1000. clear_bit(TTY_IO_ERROR, &port->tty->flags);
  1002. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  1004. gs_set_termios(port->tty, NULL);
  1006. port->flags |= ASYNC_INITIALIZED;
  1007. port->flags &= ~GS_TX_INTEN;
  1009. restore_flags(flags);
  1010. return 0;
  1011. }
  1014. int gs_setserial(struct gs_port *port, struct serial_struct *sp)
  1015. {
  1016. struct serial_struct sio;
  1018. if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
  1019. return(-EFAULT);
  1021. if (!capable(CAP_SYS_ADMIN)) {
  1022. if ((sio.baud_base != port->baud_base) ||
  1023.     (sio.close_delay != port->close_delay) ||
  1024.     ((sio.flags & ~ASYNC_USR_MASK) !=
  1025.      (port->flags & ~ASYNC_USR_MASK)))
  1026. return(-EPERM);
  1027. } 
  1029. port->flags = (port->flags & ~ASYNC_USR_MASK) |
  1030. (sio.flags & ASYNC_USR_MASK);
  1031.   
  1032. port->baud_base = sio.baud_base;
  1033. port->close_delay = sio.close_delay;
  1034. port->closing_wait = sio.closing_wait;
  1035. port->custom_divisor = sio.custom_divisor;
  1037. gs_set_termios (port->tty, NULL);
  1039. return 0;
  1040. }
  1043. /*****************************************************************************/
  1045. /*
  1046.  *      Generate the serial struct info.
  1047.  */
  1049. int gs_getserial(struct gs_port *port, struct serial_struct *sp)
  1050. {
  1051. struct serial_struct    sio;
  1053. memset(&sio, 0, sizeof(struct serial_struct));
  1054. sio.flags = port->flags;
  1055. sio.baud_base = port->baud_base;
  1056. sio.close_delay = port->close_delay;
  1057. sio.closing_wait = port->closing_wait;
  1058. sio.custom_divisor = port->custom_divisor;
  1059. sio.hub6 = 0;
  1061. /* If you want you can override these. */
  1062. sio.type = PORT_UNKNOWN;
  1063. sio.xmit_fifo_size = -1;
  1064. sio.line = -1;
  1065. sio.port = -1;
  1066. sio.irq = -1;
  1068. if (port->rd->getserial)
  1069. port->rd->getserial (port, &sio);
  1071. if (copy_to_user(sp, &sio, sizeof(struct serial_struct)))
  1072. return -EFAULT;
  1073. return 0;
  1075. }
  1078. void gs_got_break(struct gs_port *port)
  1079. {
  1080. if (port->flags & ASYNC_SAK) {
  1081. do_SAK (port->tty);
  1082. }
  1083. *(port->tty->flip.flag_buf_ptr) = TTY_BREAK;
  1084. port->tty->flip.flag_buf_ptr++;
  1085. port->tty->flip.char_buf_ptr++;
  1086. port->tty->flip.count++;
  1087. }
  1090. EXPORT_SYMBOL(gs_put_char);
  1091. EXPORT_SYMBOL(gs_write);
  1092. EXPORT_SYMBOL(gs_write_room);
  1093. EXPORT_SYMBOL(gs_chars_in_buffer);
  1094. EXPORT_SYMBOL(gs_flush_buffer);
  1095. EXPORT_SYMBOL(gs_flush_chars);
  1096. EXPORT_SYMBOL(gs_stop);
  1097. EXPORT_SYMBOL(gs_start);
  1098. EXPORT_SYMBOL(gs_hangup);
  1099. EXPORT_SYMBOL(gs_do_softint);
  1100. EXPORT_SYMBOL(gs_block_til_ready);
  1101. EXPORT_SYMBOL(gs_close);
  1102. EXPORT_SYMBOL(gs_set_termios);
  1103. EXPORT_SYMBOL(gs_init_port);
  1104. EXPORT_SYMBOL(gs_setserial);
  1105. EXPORT_SYMBOL(gs_getserial);
  1106. EXPORT_SYMBOL(gs_got_break);
  1108. MODULE_LICENSE("GPL");