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

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

嵌入式Linux

开发平台：

Unix_Linux

n_hdlc.c：源码内容
  1. /* generic HDLC line discipline for Linux
  2.  *
  3.  * Written by Paul Fulghum paulkf@microgate.com
  4.  * for Microgate Corporation
  5.  *
  6.  * Microgate and SyncLink are registered trademarks of Microgate Corporation
  7.  *
  8.  * Adapted from ppp.c, written by Michael Callahan <callahan@maths.ox.ac.uk>,
  9.  * Al Longyear <longyear@netcom.com>, Paul Mackerras <Paul.Mackerras@cs.anu.edu.au>
  10.  *
  11.  * Original release 01/11/99
  12.  * $Id: n_hdlc.c,v 3.3 2001/11/08 16:16:03 paulkf Exp $
  13.  *
  14.  * This code is released under the GNU General Public License (GPL)
  15.  *
  16.  * This module implements the tty line discipline N_HDLC for use with
  17.  * tty device drivers that support bit-synchronous HDLC communications.
  18.  *
  19.  * All HDLC data is frame oriented which means:
  20.  *
  21.  * 1. tty write calls represent one complete transmit frame of data
  22.  *    The device driver should accept the complete frame or none of 
  23.  *    the frame (busy) in the write method. Each write call should have
  24.  *    a byte count in the range of 2-65535 bytes (2 is min HDLC frame
  25.  *    with 1 addr byte and 1 ctrl byte). The max byte count of 65535
  26.  *    should include any crc bytes required. For example, when using
  27.  *    CCITT CRC32, 4 crc bytes are required, so the maximum size frame
  28.  *    the application may transmit is limited to 65531 bytes. For CCITT
  29.  *    CRC16, the maximum application frame size would be 65533.
  30.  *
  31.  *
  32.  * 2. receive callbacks from the device driver represents
  33.  *    one received frame. The device driver should bypass
  34.  *    the tty flip buffer and call the line discipline receive
  35.  *    callback directly to avoid fragmenting or concatenating
  36.  *    multiple frames into a single receive callback.
  37.  *
  38.  *    The HDLC line discipline queues the receive frames in seperate
  39.  *    buffers so complete receive frames can be returned by the
  40.  *    tty read calls.
  41.  *
  42.  * 3. tty read calls returns an entire frame of data or nothing.
  43.  *    
  44.  * 4. all send and receive data is considered raw. No processing
  45.  *    or translation is performed by the line discipline, regardless
  46.  *    of the tty flags
  47.  *
  48.  * 5. When line discipline is queried for the amount of receive
  49.  *    data available (FIOC), 0 is returned if no data available,
  50.  *    otherwise the count of the next available frame is returned.
  51.  *    (instead of the sum of all received frame counts).
  52.  *
  53.  * These conventions allow the standard tty programming interface
  54.  * to be used for synchronous HDLC applications when used with
  55.  * this line discipline (or another line discipline that is frame
  56.  * oriented such as N_PPP).
  57.  *
  58.  * The SyncLink driver (synclink.c) implements both asynchronous
  59.  * (using standard line discipline N_TTY) and synchronous HDLC
  60.  * (using N_HDLC) communications, with the latter using the above
  61.  * conventions.
  62.  *
  63.  * This implementation is very basic and does not maintain
  64.  * any statistics. The main point is to enforce the raw data
  65.  * and frame orientation of HDLC communications.
  66.  *
  67.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  68.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  69.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  70.  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  71.  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  72.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  73.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  74.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  75.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  76.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  77.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  78.  */
  80. #define HDLC_MAGIC 0x239e
  81. #define HDLC_VERSION "$Revision: 3.3 $"
  83. #include <linux/version.h>
  84. #include <linux/config.h>
  85. #include <linux/module.h>
  86. #include <linux/init.h>
  87. #include <linux/kernel.h>
  88. #include <linux/sched.h>
  89. #include <linux/types.h>
  90. #include <linux/fcntl.h>
  91. #include <linux/interrupt.h>
  92. #include <linux/ptrace.h>
  94. #undef VERSION
  95. #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
  97. #include <linux/poll.h>
  98. #include <linux/in.h>
  99. #include <linux/slab.h>
  100. #include <linux/tty.h>
  101. #include <linux/errno.h>
  102. #include <linux/string.h> /* used in new tty drivers */
  103. #include <linux/signal.h> /* used in new tty drivers */
  104. #include <asm/system.h>
  105. #include <asm/bitops.h>
  106. #include <asm/termios.h>
  107. #include <linux/if.h>
  109. #include <linux/ioctl.h>
  111. #ifdef CONFIG_KERNELD
  112. #include <linux/kerneld.h>
  113. #endif
  115. #include <asm/segment.h>
  116. #define GET_USER(error,value,addr) error = get_user(value,addr)
  117. #define COPY_FROM_USER(error,dest,src,size) error = copy_from_user(dest,src,size) ? -EFAULT : 0
  118. #define PUT_USER(error,value,addr) error = put_user(value,addr)
  119. #define COPY_TO_USER(error,dest,src,size) error = copy_to_user(dest,src,size) ? -EFAULT : 0
  121. #include <asm/uaccess.h>
  123. typedef ssize_t rw_ret_t;
  124. typedef size_t rw_count_t;
  126. /*
  127.  * Buffers for individual HDLC frames
  128.  */
  129. #define MAX_HDLC_FRAME_SIZE 65535 
  130. #define DEFAULT_RX_BUF_COUNT 10
  131. #define MAX_RX_BUF_COUNT 60
  132. #define DEFAULT_TX_BUF_COUNT 1
  135. typedef struct _n_hdlc_buf
  136. {
  137. struct _n_hdlc_buf *link;
  138. int count;
  139. char buf[1];
  140. } N_HDLC_BUF;
  142. #define N_HDLC_BUF_SIZE (sizeof(N_HDLC_BUF)+maxframe)
  144. typedef struct _n_hdlc_buf_list
  145. {
  146. N_HDLC_BUF *head;
  147. N_HDLC_BUF *tail;
  148. int count;
  149. spinlock_t spinlock;
  151. } N_HDLC_BUF_LIST;
  153. /*
  154.  * Per device instance data structure
  155.  */
  156. struct n_hdlc {
  157. int magic; /* magic value for structure */
  158. __u32 flags; /* miscellaneous control flags */
  160. struct tty_struct *tty; /* ptr to TTY structure */
  161. struct tty_struct *backup_tty; /* TTY to use if tty gets closed */
  163. int tbusy; /* reentrancy flag for tx wakeup code */
  164. int woke_up;
  165. N_HDLC_BUF *tbuf; /* currently transmitting tx buffer */
  166. N_HDLC_BUF_LIST tx_buf_list; /* list of pending transmit frame buffers */
  167. N_HDLC_BUF_LIST rx_buf_list; /* list of received frame buffers */
  168. N_HDLC_BUF_LIST tx_free_buf_list; /* list unused transmit frame buffers */
  169. N_HDLC_BUF_LIST rx_free_buf_list; /* list unused received frame buffers */
  170. };
  172. /*
  173.  * HDLC buffer list manipulation functions
  174.  */
  175. void n_hdlc_buf_list_init(N_HDLC_BUF_LIST *list);
  176. void n_hdlc_buf_put(N_HDLC_BUF_LIST *list,N_HDLC_BUF *buf);
  177. N_HDLC_BUF* n_hdlc_buf_get(N_HDLC_BUF_LIST *list);
  179. /* Local functions */
  181. static struct n_hdlc *n_hdlc_alloc (void);
  183. MODULE_PARM(debuglevel, "i");
  184. MODULE_PARM(maxframe, "i");
  187. /* debug level can be set by insmod for debugging purposes */
  188. #define DEBUG_LEVEL_INFO 1
  189. int debuglevel=0;
  191. /* max frame size for memory allocations */
  192. ssize_t maxframe=4096;
  194. /* TTY callbacks */
  196. static rw_ret_t n_hdlc_tty_read(struct tty_struct *,
  197. struct file *, __u8 *, rw_count_t);
  198. static rw_ret_t n_hdlc_tty_write(struct tty_struct *,
  199. struct file *, const __u8 *, rw_count_t);
  200. static int n_hdlc_tty_ioctl(struct tty_struct *,
  201. struct file *, unsigned int, unsigned long);
  202. static unsigned int n_hdlc_tty_poll (struct tty_struct *tty, struct file *filp,
  203.   poll_table * wait);
  204. static int n_hdlc_tty_open (struct tty_struct *);
  205. static void n_hdlc_tty_close (struct tty_struct *);
  206. static int n_hdlc_tty_room (struct tty_struct *tty);
  207. static void n_hdlc_tty_receive (struct tty_struct *tty,
  208. const __u8 * cp, char *fp, int count);
  209. static void n_hdlc_tty_wakeup (struct tty_struct *tty);
  211. #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
  213. #define tty2n_hdlc(tty) ((struct n_hdlc *) ((tty)->disc_data))
  214. #define n_hdlc2tty(n_hdlc) ((n_hdlc)->tty)
  216. /* Define this string only once for all macro invocations */
  217. static char szVersion[] = HDLC_VERSION;
  219. /* n_hdlc_release()
  220.  *
  221.  * release an n_hdlc per device line discipline info structure
  222.  *
  223.  */
  224. static void n_hdlc_release (struct n_hdlc *n_hdlc)
  225. {
  226. struct tty_struct *tty = n_hdlc2tty (n_hdlc);
  227. N_HDLC_BUF *buf;
  229. if (debuglevel >= DEBUG_LEVEL_INFO)
  230. printk("%s(%d)n_hdlc_release() calledn",__FILE__,__LINE__);
  232. /* Ensure that the n_hdlcd process is not hanging on select()/poll() */
  233. wake_up_interruptible (&tty->read_wait);
  234. wake_up_interruptible (&tty->write_wait);
  236. if (tty != NULL && tty->disc_data == n_hdlc)
  237. tty->disc_data = NULL; /* Break the tty->n_hdlc link */
  239. /* Release transmit and receive buffers */
  240. for(;;) {
  241. buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);
  242. if (buf) {
  243. kfree(buf);
  244. } else
  245. break;
  246. }
  247. for(;;) {
  248. buf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list);
  249. if (buf) {
  250. kfree(buf);
  251. } else
  252. break;
  253. }
  254. for(;;) {
  255. buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);
  256. if (buf) {
  257. kfree(buf);
  258. } else
  259. break;
  260. }
  261. for(;;) {
  262. buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
  263. if (buf) {
  264. kfree(buf);
  265. } else
  266. break;
  267. }
  269. kfree(n_hdlc);
  271. } /* end of n_hdlc_release() */
  273. /* n_hdlc_tty_close()
  274.  *
  275.  * Called when the line discipline is changed to something
  276.  * else, the tty is closed, or the tty detects a hangup.
  277.  */
  278. static void n_hdlc_tty_close(struct tty_struct *tty)
  279. {
  280. struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  282. if (debuglevel >= DEBUG_LEVEL_INFO)
  283. printk("%s(%d)n_hdlc_tty_close() calledn",__FILE__,__LINE__);
  285. if (n_hdlc != NULL) {
  286. if (n_hdlc->magic != HDLC_MAGIC) {
  287. printk (KERN_WARNING"n_hdlc: trying to close unopened tty!n");
  288. return;
  289. }
  290. #if defined(TTY_NO_WRITE_SPLIT)
  291. clear_bit(TTY_NO_WRITE_SPLIT,&tty->flags);
  292. #endif
  293. tty->disc_data = NULL;
  294. if (tty == n_hdlc->backup_tty)
  295. n_hdlc->backup_tty = 0;
  296. if (tty != n_hdlc->tty)
  297. return;
  298. if (n_hdlc->backup_tty) {
  299. n_hdlc->tty = n_hdlc->backup_tty;
  300. } else {
  301. n_hdlc_release (n_hdlc);
  302. MOD_DEC_USE_COUNT;
  303. }
  304. }
  306. if (debuglevel >= DEBUG_LEVEL_INFO)
  307. printk("%s(%d)n_hdlc_tty_close() successn",__FILE__,__LINE__);
  309. } /* end of n_hdlc_tty_close() */
  311. /* n_hdlc_tty_open
  312.  * 
  313.  *  called when line discipline changed to n_hdlc
  314.  * 
  315.  * Arguments: tty pointer to tty info structure
  316.  * Return Value: 0 if success, otherwise error code
  317.  */
  318. static int n_hdlc_tty_open (struct tty_struct *tty)
  319. {
  320. struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  322. if (debuglevel >= DEBUG_LEVEL_INFO)
  323. printk("%s(%d)n_hdlc_tty_open() called (major=%u,minor=%u)n",
  324. __FILE__,__LINE__,
  325. MAJOR(tty->device), MINOR(tty->device));
  327. /* There should not be an existing table for this slot. */
  328. if (n_hdlc) {
  329. printk (KERN_ERR"n_hdlc_tty_open:tty already associated!n" );
  330. return -EEXIST;
  331. }
  333. n_hdlc = n_hdlc_alloc();
  334. if (!n_hdlc) {
  335. printk (KERN_ERR "n_hdlc_alloc failedn");
  336. return -ENFILE;
  337. }
  339. tty->disc_data = n_hdlc;
  340. n_hdlc->tty    = tty;
  342. MOD_INC_USE_COUNT;
  344. #if defined(TTY_NO_WRITE_SPLIT)
  345. /* change tty_io write() to not split large writes into 8K chunks */
  346. set_bit(TTY_NO_WRITE_SPLIT,&tty->flags);
  347. #endif
  349. /* Flush any pending characters in the driver and discipline. */
  351. if (tty->ldisc.flush_buffer)
  352. tty->ldisc.flush_buffer (tty);
  354. if (tty->driver.flush_buffer)
  355. tty->driver.flush_buffer (tty);
  357. if (debuglevel >= DEBUG_LEVEL_INFO)
  358. printk("%s(%d)n_hdlc_tty_open() successn",__FILE__,__LINE__);
  360. return 0;
  362. } /* end of n_tty_hdlc_open() */
  364. /* n_hdlc_send_frames()
  365.  * 
  366.  *  send frames on pending send buffer list until the
  367.  *  driver does not accept a frame (busy)
  368.  *  this function is called after adding a frame to the
  369.  *  send buffer list and by the tty wakeup callback
  370.  * 
  371.  * Arguments: n_hdlc pointer to ldisc instance data
  372.  *  tty pointer to tty instance data
  373.  * Return Value: None
  374.  */
  375. static void n_hdlc_send_frames (struct n_hdlc *n_hdlc, struct tty_struct *tty)
  376. {
  377. register int actual;
  378. unsigned long flags;
  379. N_HDLC_BUF *tbuf;
  381. if (debuglevel >= DEBUG_LEVEL_INFO)
  382. printk("%s(%d)n_hdlc_send_frames() calledn",__FILE__,__LINE__);
  383.  check_again:
  385. save_flags(flags);
  386. cli ();
  387. if (n_hdlc->tbusy) {
  388. n_hdlc->woke_up = 1;
  389. restore_flags(flags);
  390. return;
  391. }
  392. n_hdlc->tbusy = 1;
  393. n_hdlc->woke_up = 0;
  394. restore_flags(flags);
  396. /* get current transmit buffer or get new transmit */
  397. /* buffer from list of pending transmit buffers */
  399. tbuf = n_hdlc->tbuf;
  400. if (!tbuf)
  401. tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
  403. while (tbuf) {
  404. if (debuglevel >= DEBUG_LEVEL_INFO)
  405. printk("%s(%d)sending frame %p, count=%dn",
  406. __FILE__,__LINE__,tbuf,tbuf->count);
  408. /* Send the next block of data to device */
  409. tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  410. actual = tty->driver.write(tty, 0, tbuf->buf, tbuf->count);
  411.     
  412. /* if transmit error, throw frame away by */
  413. /* pretending it was accepted by driver */
  414. if (actual < 0)
  415. actual = tbuf->count;
  417. if (actual == tbuf->count) {
  418. if (debuglevel >= DEBUG_LEVEL_INFO)
  419. printk("%s(%d)frame %p completedn",
  420. __FILE__,__LINE__,tbuf);
  422. /* free current transmit buffer */
  423. n_hdlc_buf_put(&n_hdlc->tx_free_buf_list,tbuf);
  425. /* this tx buffer is done */
  426. n_hdlc->tbuf = NULL;
  428. /* wait up sleeping writers */
  429. wake_up_interruptible(&tty->write_wait);
  431. /* get next pending transmit buffer */
  432. tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
  433. } else {
  434. if (debuglevel >= DEBUG_LEVEL_INFO)
  435. printk("%s(%d)frame %p pendingn",
  436. __FILE__,__LINE__,tbuf);
  438. /* buffer not accepted by driver */
  439. /* set this buffer as pending buffer */
  440. n_hdlc->tbuf = tbuf;
  441. break;
  442. }
  443. }
  445. if (!tbuf)
  446. tty->flags  &= ~(1 << TTY_DO_WRITE_WAKEUP);
  448. /* Clear the re-entry flag */
  449. save_flags(flags);
  450. cli ();
  451. n_hdlc->tbusy = 0;
  452. restore_flags(flags);
  454.         if (n_hdlc->woke_up)
  455.   goto check_again;
  457. if (debuglevel >= DEBUG_LEVEL_INFO)
  458. printk("%s(%d)n_hdlc_send_frames() exitn",__FILE__,__LINE__);
  460. } /* end of n_hdlc_send_frames() */
  462. /* n_hdlc_tty_wakeup()
  463.  *
  464.  * Callback for transmit wakeup. Called when low level
  465.  * device driver can accept more send data.
  466.  *
  467.  * Arguments: tty pointer to associated tty instance data
  468.  * Return Value: None
  469.  */
  470. static void n_hdlc_tty_wakeup (struct tty_struct *tty)
  471. {
  472. struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  474. if (debuglevel >= DEBUG_LEVEL_INFO)
  475. printk("%s(%d)n_hdlc_tty_wakeup() calledn",__FILE__,__LINE__);
  477. if (!n_hdlc)
  478. return;
  480. if (tty != n_hdlc->tty) {
  481. tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  482. return;
  483. }
  485. n_hdlc_send_frames (n_hdlc, tty);
  487. } /* end of n_hdlc_tty_wakeup() */
  489. /* n_hdlc_tty_room()
  490.  * 
  491.  * Callback function from tty driver. Return the amount of 
  492.  * space left in the receiver's buffer to decide if remote
  493.  * transmitter is to be throttled.
  494.  *
  495.  * Arguments: tty pointer to associated tty instance data
  496.  * Return Value: number of bytes left in receive buffer
  497.  */
  498. static int n_hdlc_tty_room (struct tty_struct *tty)
  499. {
  500. if (debuglevel >= DEBUG_LEVEL_INFO)
  501. printk("%s(%d)n_hdlc_tty_room() calledn",__FILE__,__LINE__);
  502. /* always return a larger number to prevent */
  503. /* throttling of remote transmitter. */
  504. return 65536;
  505. } /* end of n_hdlc_tty_root() */
  507. /* n_hdlc_tty_receive()
  508.  * 
  509.  *  Called by tty low level driver when receive data is
  510.  *  available. Data is interpreted as one HDLC frame.
  511.  * 
  512.  * Arguments:   tty pointer to tty isntance data
  513.  *  data pointer to received data
  514.  *  flags pointer to flags for data
  515.  *  count count of received data in bytes
  516.  * 
  517.  * Return Value: None
  518.  */
  519. static void n_hdlc_tty_receive(struct tty_struct *tty,
  520. const __u8 * data, char *flags, int count)
  521. {
  522. register struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  523. register N_HDLC_BUF *buf;
  525. if (debuglevel >= DEBUG_LEVEL_INFO)
  526. printk("%s(%d)n_hdlc_tty_receive() called count=%dn",
  527. __FILE__,__LINE__, count);
  529. /* This can happen if stuff comes in on the backup tty */
  530. if (n_hdlc == 0 || tty != n_hdlc->tty)
  531. return;
  533. /* verify line is using HDLC discipline */
  534. if (n_hdlc->magic != HDLC_MAGIC) {
  535. printk("%s(%d) line not using HDLC disciplinen",
  536. __FILE__,__LINE__);
  537. return;
  538. }
  540. if ( count>maxframe ) {
  541. if (debuglevel >= DEBUG_LEVEL_INFO)
  542. printk("%s(%d) rx count>maxframesize, data discardedn",
  543.        __FILE__,__LINE__);
  544. return;
  545. }
  547. /* get a free HDLC buffer */
  548. buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);
  549. if (!buf) {
  550. /* no buffers in free list, attempt to allocate another rx buffer */
  551. /* unless the maximum count has been reached */
  552. if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT)
  553. buf = (N_HDLC_BUF*)kmalloc(N_HDLC_BUF_SIZE,GFP_ATOMIC);
  554. }
  556. if (!buf) {
  557. if (debuglevel >= DEBUG_LEVEL_INFO)
  558. printk("%s(%d) no more rx buffers, data discardedn",
  559.        __FILE__,__LINE__);
  560. return;
  561. }
  563. /* copy received data to HDLC buffer */
  564. memcpy(buf->buf,data,count);
  565. buf->count=count;
  567. /* add HDLC buffer to list of received frames */
  568. n_hdlc_buf_put(&n_hdlc->rx_buf_list,buf);
  570. /* wake up any blocked reads and perform async signalling */
  571. wake_up_interruptible (&tty->read_wait);
  572. if (n_hdlc->tty->fasync != NULL)
  573. kill_fasync (&n_hdlc->tty->fasync, SIGIO, POLL_IN);
  575. } /* end of n_hdlc_tty_receive() */
  577. /* n_hdlc_tty_read()
  578.  * 
  579.  *  Called to retreive one frame of data (if available)
  580.  * 
  581.  * Arguments:
  582.  * 
  583.  *  tty pointer to tty instance data
  584.  *  file pointer to open file object
  585.  *  buf pointer to returned data buffer
  586.  *  nr size of returned data buffer
  587.  * 
  588.  * Return Value:
  589.  * 
  590.  *  Number of bytes returned or error code
  591.  */
  592. static rw_ret_t n_hdlc_tty_read (struct tty_struct *tty,
  593. struct file *file, __u8 * buf, rw_count_t nr)
  594. {
  595. struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
  596. int error;
  597. rw_ret_t ret;
  598. N_HDLC_BUF *rbuf;
  600. if (debuglevel >= DEBUG_LEVEL_INFO)
  601. printk("%s(%d)n_hdlc_tty_read() calledn",__FILE__,__LINE__);
  603. /* Validate the pointers */
  604. if (!n_hdlc)
  605. return -EIO;
  607. /* verify user access to buffer */
  608. error = verify_area (VERIFY_WRITE, buf, nr);
  609. if (error != 0) {
  610. printk(KERN_WARNING"%s(%d) n_hdlc_tty_read() can't verify user "
  611. "buffern",__FILE__,__LINE__);
  612. return (error);
  613. }
  615. for (;;) {
  616. if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
  617. return -EIO;
  619. n_hdlc = tty2n_hdlc (tty);
  620. if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC ||
  621.  tty != n_hdlc->tty)
  622. return 0;
  624. rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);
  625. if (rbuf)
  626. break;
  628. /* no data */
  629. if (file->f_flags & O_NONBLOCK)
  630. return -EAGAIN;
  632. interruptible_sleep_on (&tty->read_wait);
  633. if (signal_pending(current))
  634. return -EINTR;
  635. }
  637. if (rbuf->count > nr) {
  638. /* frame too large for caller's buffer (discard frame) */
  639. ret = (rw_ret_t)-EOVERFLOW;
  640. } else {
  641. /* Copy the data to the caller's buffer */
  642. COPY_TO_USER(error,buf,rbuf->buf,rbuf->count);
  643. if (error)
  644. ret = (rw_ret_t)error;
  645. else
  646. ret = (rw_ret_t)rbuf->count;
  647. }
  649. /* return HDLC buffer to free list unless the free list */
  650. /* count has exceeded the default value, in which case the */
  651. /* buffer is freed back to the OS to conserve memory */
  652. if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT)
  653. kfree(rbuf);
  654. else
  655. n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,rbuf);
  657. return ret;
  659. } /* end of n_hdlc_tty_read() */
  661. /* n_hdlc_tty_write()
  662.  * 
  663.  *  write a single frame of data to device
  664.  * 
  665.  * Arguments: tty pointer to associated tty device instance data
  666.  *  file pointer to file object data
  667.  *  data pointer to transmit data (one frame)
  668.  *  count size of transmit frame in bytes
  669.  * 
  670.  * Return Value: number of bytes written (or error code)
  671.  */
  672. static rw_ret_t n_hdlc_tty_write (struct tty_struct *tty, struct file *file,
  673. const __u8 * data, rw_count_t count)
  674. {
  675. struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  676. int error = 0;
  677. DECLARE_WAITQUEUE(wait, current);
  678. N_HDLC_BUF *tbuf;
  680. if (debuglevel >= DEBUG_LEVEL_INFO)
  681. printk("%s(%d)n_hdlc_tty_write() called count=%dn",
  682. __FILE__,__LINE__,count);
  684. /* Verify pointers */
  685. if (!n_hdlc)
  686. return -EIO;
  688. if (n_hdlc->magic != HDLC_MAGIC)
  689. return -EIO;
  691. /* verify frame size */
  692. if (count > maxframe ) {
  693. if (debuglevel & DEBUG_LEVEL_INFO)
  694. printk (KERN_WARNING
  695. "n_hdlc_tty_write: truncating user packet "
  696. "from %lu to %dn", (unsigned long) count,
  697. maxframe );
  698. count = maxframe;
  699. }
  701. add_wait_queue(&tty->write_wait, &wait);
  702. set_current_state(TASK_INTERRUPTIBLE);
  704. /* Allocate transmit buffer */
  705. /* sleep until transmit buffer available */
  706. while (!(tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list))) {
  707. schedule();
  709. n_hdlc = tty2n_hdlc (tty);
  710. if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC || 
  711.     tty != n_hdlc->tty) {
  712. printk("n_hdlc_tty_write: %p invalid after wait!n", n_hdlc);
  713. error = -EIO;
  714. break;
  715. }
  717. if (signal_pending(current)) {
  718. error = -EINTR;
  719. break;
  720. }
  721. }
  723. set_current_state(TASK_RUNNING);
  724. remove_wait_queue(&tty->write_wait, &wait);
  726. if (!error) {
  727. /* Retrieve the user's buffer */
  728. COPY_FROM_USER (error, tbuf->buf, data, count);
  729. if (error) {
  730. /* return tx buffer to free list */
  731. n_hdlc_buf_put(&n_hdlc->tx_free_buf_list,tbuf);
  732. } else {
  733. /* Send the data */
  734. tbuf->count = error = count;
  735. n_hdlc_buf_put(&n_hdlc->tx_buf_list,tbuf);
  736. n_hdlc_send_frames(n_hdlc,tty);
  737. }
  738. }
  740. return error;
  742. } /* end of n_hdlc_tty_write() */
  744. /* n_hdlc_tty_ioctl()
  745.  *
  746.  * Process IOCTL system call for the tty device.
  747.  *
  748.  * Arguments:
  749.  *
  750.  * tty pointer to tty instance data
  751.  * file pointer to open file object for device
  752.  * cmd IOCTL command code
  753.  * arg argument for IOCTL call (cmd dependent)
  754.  *
  755.  * Return Value: Command dependent
  756.  */
  757. static int n_hdlc_tty_ioctl (struct tty_struct *tty, struct file * file,
  758.                unsigned int cmd, unsigned long arg)
  759. {
  760. struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  761. int error = 0;
  762. int count;
  763. unsigned long flags;
  765. if (debuglevel >= DEBUG_LEVEL_INFO)
  766. printk("%s(%d)n_hdlc_tty_ioctl() called %dn",
  767. __FILE__,__LINE__,cmd);
  769. /* Verify the status of the device */
  770. if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC)
  771. return -EBADF;
  773. switch (cmd) {
  774. case FIONREAD:
  775. /* report count of read data available */
  776. /* in next available frame (if any) */
  777. spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags);
  778. if (n_hdlc->rx_buf_list.head)
  779. count = n_hdlc->rx_buf_list.head->count;
  780. else
  781. count = 0;
  782. spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock,flags);
  783. PUT_USER (error, count, (int *) arg);
  784. break;
  786. case TIOCOUTQ:
  787. /* get the pending tx byte count in the driver */
  788. count = tty->driver.chars_in_buffer ?
  789. tty->driver.chars_in_buffer(tty) : 0;
  790. /* add size of next output frame in queue */
  791. spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);
  792. if (n_hdlc->tx_buf_list.head)
  793. count += n_hdlc->tx_buf_list.head->count;
  794. spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags);
  795. PUT_USER (error, count, (int*)arg);
  796. break;
  798. default:
  799. error = n_tty_ioctl (tty, file, cmd, arg);
  800. break;
  801. }
  802. return error;
  804. } /* end of n_hdlc_tty_ioctl() */
  806. /* n_hdlc_tty_poll()
  807.  * 
  808.  *  TTY callback for poll system call. Determine which 
  809.  *  operations (read/write) will not block and return
  810.  *  info to caller.
  811.  * 
  812.  * Arguments:
  813.  * 
  814.  *  tty pointer to tty instance data
  815.  *  filp pointer to open file object for device
  816.  *  poll_table wait queue for operations
  817.  * 
  818.  * Return Value:
  819.  * 
  820.  *  bit mask containing info on which ops will not block
  821.  */
  822. static unsigned int n_hdlc_tty_poll (struct tty_struct *tty,
  823.  struct file *filp, poll_table * wait)
  824. {
  825. struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
  826. unsigned int mask = 0;
  828. if (debuglevel >= DEBUG_LEVEL_INFO)
  829. printk("%s(%d)n_hdlc_tty_poll() calledn",__FILE__,__LINE__);
  831. if (n_hdlc && n_hdlc->magic == HDLC_MAGIC && tty == n_hdlc->tty) {
  832. /* queue current process into any wait queue that */
  833. /* may awaken in the future (read and write) */
  835. poll_wait(filp, &tty->read_wait, wait);
  836. poll_wait(filp, &tty->write_wait, wait);
  838. /* set bits for operations that wont block */
  839. if(n_hdlc->rx_buf_list.head)
  840. mask |= POLLIN | POLLRDNORM; /* readable */
  841. if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
  842. mask |= POLLHUP;
  843. if(tty_hung_up_p(filp))
  844. mask |= POLLHUP;
  845. if(n_hdlc->tx_free_buf_list.head)
  846. mask |= POLLOUT | POLLWRNORM; /* writable */
  847. }
  848. return mask;
  849. } /* end of n_hdlc_tty_poll() */
  851. /* n_hdlc_alloc()
  852.  * 
  853.  *  Allocate an n_hdlc instance data structure
  854.  *
  855.  * Arguments: None
  856.  * Return Value: pointer to structure if success, otherwise 0
  857.  */
  858. static struct n_hdlc *n_hdlc_alloc (void)
  859. {
  860. struct n_hdlc *n_hdlc;
  861. N_HDLC_BUF *buf;
  862. int i;
  864. n_hdlc = (struct n_hdlc *)kmalloc(sizeof(struct n_hdlc), GFP_KERNEL);
  865. if (!n_hdlc)
  866. return 0;
  868. memset(n_hdlc, 0, sizeof(*n_hdlc));
  870. n_hdlc_buf_list_init(&n_hdlc->rx_free_buf_list);
  871. n_hdlc_buf_list_init(&n_hdlc->tx_free_buf_list);
  872. n_hdlc_buf_list_init(&n_hdlc->rx_buf_list);
  873. n_hdlc_buf_list_init(&n_hdlc->tx_buf_list);
  875. /* allocate free rx buffer list */
  876. for(i=0;i<DEFAULT_RX_BUF_COUNT;i++) {
  877. buf = (N_HDLC_BUF*)kmalloc(N_HDLC_BUF_SIZE,GFP_KERNEL);
  878. if (buf)
  879. n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,buf);
  880. else if (debuglevel >= DEBUG_LEVEL_INFO)
  881. printk("%s(%d)n_hdlc_alloc(), kalloc() failed for rx buffer %dn",__FILE__,__LINE__, i);
  882. }
  884. /* allocate free tx buffer list */
  885. for(i=0;i<DEFAULT_TX_BUF_COUNT;i++) {
  886. buf = (N_HDLC_BUF*)kmalloc(N_HDLC_BUF_SIZE,GFP_KERNEL);
  887. if (buf)
  888. n_hdlc_buf_put(&n_hdlc->tx_free_buf_list,buf);
  889. else if (debuglevel >= DEBUG_LEVEL_INFO)
  890. printk("%s(%d)n_hdlc_alloc(), kalloc() failed for tx buffer %dn",__FILE__,__LINE__, i);
  891. }
  893. /* Initialize the control block */
  894. n_hdlc->magic  = HDLC_MAGIC;
  895. n_hdlc->flags  = 0;
  897. return n_hdlc;
  899. } /* end of n_hdlc_alloc() */
  901. /* n_hdlc_buf_list_init()
  902.  * 
  903.  *  initialize specified HDLC buffer list
  904.  * 
  905.  * Arguments:   list pointer to buffer list
  906.  * Return Value: None
  907.  */
  908. void n_hdlc_buf_list_init(N_HDLC_BUF_LIST *list)
  909. {
  910. memset(list,0,sizeof(N_HDLC_BUF_LIST));
  911. spin_lock_init(&list->spinlock);
  912. } /* end of n_hdlc_buf_list_init() */
  914. /* n_hdlc_buf_put()
  915.  * 
  916.  *  add specified HDLC buffer to tail of specified list
  917.  * 
  918.  * Arguments:
  919.  * 
  920.  *  list pointer to buffer list
  921.  *  buf pointer to buffer
  922.  * 
  923.  * Return Value: None
  924.  */
  925. void n_hdlc_buf_put(N_HDLC_BUF_LIST *list,N_HDLC_BUF *buf)
  926. {
  927. unsigned long flags;
  928. spin_lock_irqsave(&list->spinlock,flags);
  930. buf->link=NULL;
  931. if(list->tail)
  932. list->tail->link = buf;
  933. else
  934. list->head = buf;
  935. list->tail = buf;
  936. (list->count)++;
  938. spin_unlock_irqrestore(&list->spinlock,flags);
  940. } /* end of n_hdlc_buf_put() */
  942. /* n_hdlc_buf_get()
  943.  * 
  944.  *  remove and return an HDLC buffer from the
  945.  *  head of the specified HDLC buffer list
  946.  * 
  947.  * Arguments:
  948.  * 
  949.  *  list pointer to HDLC buffer list
  950.  * 
  951.  * Return Value:
  952.  * 
  953.  *  pointer to HDLC buffer if available, otherwise NULL
  954.  */
  955. N_HDLC_BUF* n_hdlc_buf_get(N_HDLC_BUF_LIST *list)
  956. {
  957. unsigned long flags;
  958. N_HDLC_BUF *buf;
  959. spin_lock_irqsave(&list->spinlock,flags);
  961. buf = list->head;
  962. if (buf) {
  963. list->head = buf->link;
  964. (list->count)--;
  965. }
  966. if (!list->head)
  967. list->tail = NULL;
  969. spin_unlock_irqrestore(&list->spinlock,flags);
  970. return buf;
  972. } /* end of n_hdlc_buf_get() */
  974. static int __init n_hdlc_init(void)
  975. {
  976. static struct tty_ldisc n_hdlc_ldisc;
  977. int    status;
  979. /* range check maxframe arg */
  980. if ( maxframe<4096)
  981. maxframe=4096;
  982. else if ( maxframe>65535)
  983. maxframe=65535;
  985. printk("HDLC line discipline: version %s, maxframe=%un", 
  986. szVersion, maxframe);
  988. /* Register the tty discipline */
  990. memset(&n_hdlc_ldisc, 0, sizeof (n_hdlc_ldisc));
  991. n_hdlc_ldisc.magic = TTY_LDISC_MAGIC;
  992. n_hdlc_ldisc.name           = "hdlc";
  993. n_hdlc_ldisc.open = n_hdlc_tty_open;
  994. n_hdlc_ldisc.close = n_hdlc_tty_close;
  995. n_hdlc_ldisc.read = n_hdlc_tty_read;
  996. n_hdlc_ldisc.write = n_hdlc_tty_write;
  997. n_hdlc_ldisc.ioctl = n_hdlc_tty_ioctl;
  998. n_hdlc_ldisc.poll = n_hdlc_tty_poll;
  999. n_hdlc_ldisc.receive_room = n_hdlc_tty_room;
  1000. n_hdlc_ldisc.receive_buf = n_hdlc_tty_receive;
  1001. n_hdlc_ldisc.write_wakeup = n_hdlc_tty_wakeup;
  1003. status = tty_register_ldisc(N_HDLC, &n_hdlc_ldisc);
  1004. if (!status)
  1005. printk (KERN_INFO"N_HDLC line discipline registered.n");
  1006. else
  1007. printk (KERN_ERR"error registering line discipline: %dn",status);
  1009. if (status)
  1010. printk(KERN_INFO"N_HDLC: init failure %dn", status);
  1011. return (status);
  1013. } /* end of init_module() */
  1015. static void __exit n_hdlc_exit(void)
  1016. {
  1017. int status;
  1018. /* Release tty registration of line discipline */
  1019. if ((status = tty_register_ldisc(N_HDLC, NULL)))
  1020. printk("N_HDLC: can't unregister line discipline (err = %d)n", status);
  1021. else
  1022. printk("N_HDLC: line discipline unregisteredn");
  1023. }
  1025. module_init(n_hdlc_init);
  1026. module_exit(n_hdlc_exit);
  1028. MODULE_LICENSE("GPL");
  1029. EXPORT_NO_SYMBOLS;