1 /* generic HDLC line discipline for Linux
3 * Written by Paul Fulghum paulkf@microgate.com
4 * for Microgate Corporation
6 * Microgate and SyncLink are registered trademarks of Microgate Corporation
8 * Adapted from ppp.c, written by Michael Callahan <callahan@maths.ox.ac.uk>,
9 * Al Longyear <longyear@netcom.com>,
10 * Paul Mackerras <Paul.Mackerras@cs.anu.edu.au>
12 * Original release 01/11/99
13 * $Id: n_hdlc.c,v 4.8 2003/05/06 21:18:51 paulkf Exp $
15 * This code is released under the GNU General Public License (GPL)
17 * This module implements the tty line discipline N_HDLC for use with
18 * tty device drivers that support bit-synchronous HDLC communications.
20 * All HDLC data is frame oriented which means:
22 * 1. tty write calls represent one complete transmit frame of data
23 * The device driver should accept the complete frame or none of
24 * the frame (busy) in the write method. Each write call should have
25 * a byte count in the range of 2-65535 bytes (2 is min HDLC frame
26 * with 1 addr byte and 1 ctrl byte). The max byte count of 65535
27 * should include any crc bytes required. For example, when using
28 * CCITT CRC32, 4 crc bytes are required, so the maximum size frame
29 * the application may transmit is limited to 65531 bytes. For CCITT
30 * CRC16, the maximum application frame size would be 65533.
33 * 2. receive callbacks from the device driver represents
34 * one received frame. The device driver should bypass
35 * the tty flip buffer and call the line discipline receive
36 * callback directly to avoid fragmenting or concatenating
37 * multiple frames into a single receive callback.
39 * The HDLC line discipline queues the receive frames in separate
40 * buffers so complete receive frames can be returned by the
43 * 3. tty read calls returns an entire frame of data or nothing.
45 * 4. all send and receive data is considered raw. No processing
46 * or translation is performed by the line discipline, regardless
49 * 5. When line discipline is queried for the amount of receive
50 * data available (FIOC), 0 is returned if no data available,
51 * otherwise the count of the next available frame is returned.
52 * (instead of the sum of all received frame counts).
54 * These conventions allow the standard tty programming interface
55 * to be used for synchronous HDLC applications when used with
56 * this line discipline (or another line discipline that is frame
57 * oriented such as N_PPP).
59 * The SyncLink driver (synclink.c) implements both asynchronous
60 * (using standard line discipline N_TTY) and synchronous HDLC
61 * (using N_HDLC) communications, with the latter using the above
64 * This implementation is very basic and does not maintain
65 * any statistics. The main point is to enforce the raw data
66 * and frame orientation of HDLC communications.
68 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
69 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
70 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
71 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
72 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
73 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
74 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
75 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
76 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
77 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
78 * OF THE POSSIBILITY OF SUCH DAMAGE.
81 #define HDLC_MAGIC 0x239e
82 #define HDLC_VERSION "$Revision: 4.8 $"
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>
95 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
97 #include <linux/poll.h>
99 #include <linux/ioctl.h>
100 #include <linux/slab.h>
101 #include <linux/tty.h>
102 #include <linux/errno.h>
103 #include <linux/string.h> /* used in new tty drivers */
104 #include <linux/signal.h> /* used in new tty drivers */
105 #include <linux/if.h>
106 #include <linux/bitops.h>
108 #include <asm/system.h>
109 #include <asm/termios.h>
110 #include <asm/uaccess.h>
113 * Buffers for individual HDLC frames
115 #define MAX_HDLC_FRAME_SIZE 65535
116 #define DEFAULT_RX_BUF_COUNT 10
117 #define MAX_RX_BUF_COUNT 60
118 #define DEFAULT_TX_BUF_COUNT 1
121 struct n_hdlc_buf
*link
;
126 #define N_HDLC_BUF_SIZE (sizeof(struct n_hdlc_buf) + maxframe)
128 struct n_hdlc_buf_list
{
129 struct n_hdlc_buf
*head
;
130 struct n_hdlc_buf
*tail
;
136 * struct n_hdlc - per device instance data structure
137 * @magic - magic value for structure
138 * @flags - miscellaneous control flags
139 * @tty - ptr to TTY structure
140 * @backup_tty - TTY to use if tty gets closed
141 * @tbusy - reentrancy flag for tx wakeup code
142 * @woke_up - FIXME: describe this field
143 * @tbuf - currently transmitting tx buffer
144 * @tx_buf_list - list of pending transmit frame buffers
145 * @rx_buf_list - list of received frame buffers
146 * @tx_free_buf_list - list unused transmit frame buffers
147 * @rx_free_buf_list - list unused received frame buffers
152 struct tty_struct
*tty
;
153 struct tty_struct
*backup_tty
;
156 struct n_hdlc_buf
*tbuf
;
157 struct n_hdlc_buf_list tx_buf_list
;
158 struct n_hdlc_buf_list rx_buf_list
;
159 struct n_hdlc_buf_list tx_free_buf_list
;
160 struct n_hdlc_buf_list rx_free_buf_list
;
164 * HDLC buffer list manipulation functions
166 static void n_hdlc_buf_list_init(struct n_hdlc_buf_list
*list
);
167 static void n_hdlc_buf_put(struct n_hdlc_buf_list
*list
,
168 struct n_hdlc_buf
*buf
);
169 static struct n_hdlc_buf
*n_hdlc_buf_get(struct n_hdlc_buf_list
*list
);
171 /* Local functions */
173 static struct n_hdlc
*n_hdlc_alloc (void);
175 /* debug level can be set by insmod for debugging purposes */
176 #define DEBUG_LEVEL_INFO 1
177 static int debuglevel
;
179 /* max frame size for memory allocations */
180 static int maxframe
= 4096;
184 static ssize_t
n_hdlc_tty_read(struct tty_struct
*tty
, struct file
*file
,
185 __u8 __user
*buf
, size_t nr
);
186 static ssize_t
n_hdlc_tty_write(struct tty_struct
*tty
, struct file
*file
,
187 const unsigned char *buf
, size_t nr
);
188 static int n_hdlc_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
189 unsigned int cmd
, unsigned long arg
);
190 static unsigned int n_hdlc_tty_poll(struct tty_struct
*tty
, struct file
*filp
,
192 static int n_hdlc_tty_open(struct tty_struct
*tty
);
193 static void n_hdlc_tty_close(struct tty_struct
*tty
);
194 static int n_hdlc_tty_room(struct tty_struct
*tty
);
195 static void n_hdlc_tty_receive(struct tty_struct
*tty
, const __u8
*cp
,
196 char *fp
, int count
);
197 static void n_hdlc_tty_wakeup(struct tty_struct
*tty
);
199 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
201 #define tty2n_hdlc(tty) ((struct n_hdlc *) ((tty)->disc_data))
202 #define n_hdlc2tty(n_hdlc) ((n_hdlc)->tty)
204 static struct tty_ldisc n_hdlc_ldisc
= {
205 .owner
= THIS_MODULE
,
206 .magic
= TTY_LDISC_MAGIC
,
208 .open
= n_hdlc_tty_open
,
209 .close
= n_hdlc_tty_close
,
210 .read
= n_hdlc_tty_read
,
211 .write
= n_hdlc_tty_write
,
212 .ioctl
= n_hdlc_tty_ioctl
,
213 .poll
= n_hdlc_tty_poll
,
214 .receive_buf
= n_hdlc_tty_receive
,
215 .write_wakeup
= n_hdlc_tty_wakeup
,
219 * n_hdlc_release - release an n_hdlc per device line discipline info structure
220 * @n_hdlc - per device line discipline info structure
222 static void n_hdlc_release(struct n_hdlc
*n_hdlc
)
224 struct tty_struct
*tty
= n_hdlc2tty (n_hdlc
);
225 struct n_hdlc_buf
*buf
;
227 if (debuglevel
>= DEBUG_LEVEL_INFO
)
228 printk("%s(%d)n_hdlc_release() called\n",__FILE__
,__LINE__
);
230 /* Ensure that the n_hdlcd process is not hanging on select()/poll() */
231 wake_up_interruptible (&tty
->read_wait
);
232 wake_up_interruptible (&tty
->write_wait
);
234 if (tty
!= NULL
&& tty
->disc_data
== n_hdlc
)
235 tty
->disc_data
= NULL
; /* Break the tty->n_hdlc link */
237 /* Release transmit and receive buffers */
239 buf
= n_hdlc_buf_get(&n_hdlc
->rx_free_buf_list
);
246 buf
= n_hdlc_buf_get(&n_hdlc
->tx_free_buf_list
);
253 buf
= n_hdlc_buf_get(&n_hdlc
->rx_buf_list
);
260 buf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
);
269 } /* end of n_hdlc_release() */
272 * n_hdlc_tty_close - line discipline close
273 * @tty - pointer to tty info structure
275 * Called when the line discipline is changed to something
276 * else, the tty is closed, or the tty detects a hangup.
278 static void n_hdlc_tty_close(struct tty_struct
*tty
)
280 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
282 if (debuglevel
>= DEBUG_LEVEL_INFO
)
283 printk("%s(%d)n_hdlc_tty_close() called\n",__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");
290 #if defined(TTY_NO_WRITE_SPLIT)
291 clear_bit(TTY_NO_WRITE_SPLIT
,&tty
->flags
);
293 tty
->disc_data
= NULL
;
294 if (tty
== n_hdlc
->backup_tty
)
295 n_hdlc
->backup_tty
= NULL
;
296 if (tty
!= n_hdlc
->tty
)
298 if (n_hdlc
->backup_tty
) {
299 n_hdlc
->tty
= n_hdlc
->backup_tty
;
301 n_hdlc_release (n_hdlc
);
305 if (debuglevel
>= DEBUG_LEVEL_INFO
)
306 printk("%s(%d)n_hdlc_tty_close() success\n",__FILE__
,__LINE__
);
308 } /* end of n_hdlc_tty_close() */
311 * n_hdlc_tty_open - called when line discipline changed to n_hdlc
312 * @tty - pointer to tty info structure
314 * Returns 0 if success, otherwise error code
316 static int n_hdlc_tty_open (struct tty_struct
*tty
)
318 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
320 if (debuglevel
>= DEBUG_LEVEL_INFO
)
321 printk("%s(%d)n_hdlc_tty_open() called (device=%s)\n",
325 /* There should not be an existing table for this slot. */
327 printk (KERN_ERR
"n_hdlc_tty_open:tty already associated!\n" );
331 n_hdlc
= n_hdlc_alloc();
333 printk (KERN_ERR
"n_hdlc_alloc failed\n");
337 tty
->disc_data
= n_hdlc
;
339 tty
->receive_room
= 65536;
341 #if defined(TTY_NO_WRITE_SPLIT)
342 /* change tty_io write() to not split large writes into 8K chunks */
343 set_bit(TTY_NO_WRITE_SPLIT
,&tty
->flags
);
346 /* Flush any pending characters in the driver and discipline. */
348 if (tty
->ldisc
.flush_buffer
)
349 tty
->ldisc
.flush_buffer (tty
);
351 if (tty
->driver
->flush_buffer
)
352 tty
->driver
->flush_buffer (tty
);
354 if (debuglevel
>= DEBUG_LEVEL_INFO
)
355 printk("%s(%d)n_hdlc_tty_open() success\n",__FILE__
,__LINE__
);
359 } /* end of n_tty_hdlc_open() */
362 * n_hdlc_send_frames - send frames on pending send buffer list
363 * @n_hdlc - pointer to ldisc instance data
364 * @tty - pointer to tty instance data
366 * Send frames on pending send buffer list until the driver does not accept a
367 * frame (busy) this function is called after adding a frame to the send buffer
368 * list and by the tty wakeup callback.
370 static void n_hdlc_send_frames(struct n_hdlc
*n_hdlc
, struct tty_struct
*tty
)
374 struct n_hdlc_buf
*tbuf
;
376 if (debuglevel
>= DEBUG_LEVEL_INFO
)
377 printk("%s(%d)n_hdlc_send_frames() called\n",__FILE__
,__LINE__
);
380 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
383 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
388 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
390 /* get current transmit buffer or get new transmit */
391 /* buffer from list of pending transmit buffers */
395 tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
);
398 if (debuglevel
>= DEBUG_LEVEL_INFO
)
399 printk("%s(%d)sending frame %p, count=%d\n",
400 __FILE__
,__LINE__
,tbuf
,tbuf
->count
);
402 /* Send the next block of data to device */
403 tty
->flags
|= (1 << TTY_DO_WRITE_WAKEUP
);
404 actual
= tty
->driver
->write(tty
, tbuf
->buf
, tbuf
->count
);
406 /* if transmit error, throw frame away by */
407 /* pretending it was accepted by driver */
409 actual
= tbuf
->count
;
411 if (actual
== tbuf
->count
) {
412 if (debuglevel
>= DEBUG_LEVEL_INFO
)
413 printk("%s(%d)frame %p completed\n",
414 __FILE__
,__LINE__
,tbuf
);
416 /* free current transmit buffer */
417 n_hdlc_buf_put(&n_hdlc
->tx_free_buf_list
, tbuf
);
419 /* this tx buffer is done */
422 /* wait up sleeping writers */
423 wake_up_interruptible(&tty
->write_wait
);
425 /* get next pending transmit buffer */
426 tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
);
428 if (debuglevel
>= DEBUG_LEVEL_INFO
)
429 printk("%s(%d)frame %p pending\n",
430 __FILE__
,__LINE__
,tbuf
);
432 /* buffer not accepted by driver */
433 /* set this buffer as pending buffer */
440 tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
442 /* Clear the re-entry flag */
443 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
445 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
450 if (debuglevel
>= DEBUG_LEVEL_INFO
)
451 printk("%s(%d)n_hdlc_send_frames() exit\n",__FILE__
,__LINE__
);
453 } /* end of n_hdlc_send_frames() */
456 * n_hdlc_tty_wakeup - Callback for transmit wakeup
457 * @tty - pointer to associated tty instance data
459 * Called when low level device driver can accept more send data.
461 static void n_hdlc_tty_wakeup(struct tty_struct
*tty
)
463 struct n_hdlc
*n_hdlc
= tty2n_hdlc(tty
);
465 if (debuglevel
>= DEBUG_LEVEL_INFO
)
466 printk("%s(%d)n_hdlc_tty_wakeup() called\n",__FILE__
,__LINE__
);
471 if (tty
!= n_hdlc
->tty
) {
472 tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
476 n_hdlc_send_frames (n_hdlc
, tty
);
478 } /* end of n_hdlc_tty_wakeup() */
481 * n_hdlc_tty_receive - Called by tty driver when receive data is available
482 * @tty - pointer to tty instance data
483 * @data - pointer to received data
484 * @flags - pointer to flags for data
485 * @count - count of received data in bytes
487 * Called by tty low level driver when receive data is available. Data is
488 * interpreted as one HDLC frame.
490 static void n_hdlc_tty_receive(struct tty_struct
*tty
, const __u8
*data
,
491 char *flags
, int count
)
493 register struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
494 register struct n_hdlc_buf
*buf
;
496 if (debuglevel
>= DEBUG_LEVEL_INFO
)
497 printk("%s(%d)n_hdlc_tty_receive() called count=%d\n",
498 __FILE__
,__LINE__
, count
);
500 /* This can happen if stuff comes in on the backup tty */
501 if (n_hdlc
== 0 || tty
!= n_hdlc
->tty
)
504 /* verify line is using HDLC discipline */
505 if (n_hdlc
->magic
!= HDLC_MAGIC
) {
506 printk("%s(%d) line not using HDLC discipline\n",
511 if ( count
>maxframe
) {
512 if (debuglevel
>= DEBUG_LEVEL_INFO
)
513 printk("%s(%d) rx count>maxframesize, data discarded\n",
518 /* get a free HDLC buffer */
519 buf
= n_hdlc_buf_get(&n_hdlc
->rx_free_buf_list
);
521 /* no buffers in free list, attempt to allocate another rx buffer */
522 /* unless the maximum count has been reached */
523 if (n_hdlc
->rx_buf_list
.count
< MAX_RX_BUF_COUNT
)
524 buf
= kmalloc(N_HDLC_BUF_SIZE
, GFP_ATOMIC
);
528 if (debuglevel
>= DEBUG_LEVEL_INFO
)
529 printk("%s(%d) no more rx buffers, data discarded\n",
534 /* copy received data to HDLC buffer */
535 memcpy(buf
->buf
,data
,count
);
538 /* add HDLC buffer to list of received frames */
539 n_hdlc_buf_put(&n_hdlc
->rx_buf_list
, buf
);
541 /* wake up any blocked reads and perform async signalling */
542 wake_up_interruptible (&tty
->read_wait
);
543 if (n_hdlc
->tty
->fasync
!= NULL
)
544 kill_fasync (&n_hdlc
->tty
->fasync
, SIGIO
, POLL_IN
);
546 } /* end of n_hdlc_tty_receive() */
549 * n_hdlc_tty_read - Called to retrieve one frame of data (if available)
550 * @tty - pointer to tty instance data
551 * @file - pointer to open file object
552 * @buf - pointer to returned data buffer
553 * @nr - size of returned data buffer
555 * Returns the number of bytes returned or error code.
557 static ssize_t
n_hdlc_tty_read(struct tty_struct
*tty
, struct file
*file
,
558 __u8 __user
*buf
, size_t nr
)
560 struct n_hdlc
*n_hdlc
= tty2n_hdlc(tty
);
562 struct n_hdlc_buf
*rbuf
;
564 if (debuglevel
>= DEBUG_LEVEL_INFO
)
565 printk("%s(%d)n_hdlc_tty_read() called\n",__FILE__
,__LINE__
);
567 /* Validate the pointers */
571 /* verify user access to buffer */
572 if (!access_ok(VERIFY_WRITE
, buf
, nr
)) {
573 printk(KERN_WARNING
"%s(%d) n_hdlc_tty_read() can't verify user "
574 "buffer\n", __FILE__
, __LINE__
);
579 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
))
582 n_hdlc
= tty2n_hdlc (tty
);
583 if (!n_hdlc
|| n_hdlc
->magic
!= HDLC_MAGIC
||
587 rbuf
= n_hdlc_buf_get(&n_hdlc
->rx_buf_list
);
592 if (file
->f_flags
& O_NONBLOCK
)
595 interruptible_sleep_on (&tty
->read_wait
);
596 if (signal_pending(current
))
600 if (rbuf
->count
> nr
)
601 /* frame too large for caller's buffer (discard frame) */
604 /* Copy the data to the caller's buffer */
605 if (copy_to_user(buf
, rbuf
->buf
, rbuf
->count
))
611 /* return HDLC buffer to free list unless the free list */
612 /* count has exceeded the default value, in which case the */
613 /* buffer is freed back to the OS to conserve memory */
614 if (n_hdlc
->rx_free_buf_list
.count
> DEFAULT_RX_BUF_COUNT
)
617 n_hdlc_buf_put(&n_hdlc
->rx_free_buf_list
,rbuf
);
621 } /* end of n_hdlc_tty_read() */
624 * n_hdlc_tty_write - write a single frame of data to device
625 * @tty - pointer to associated tty device instance data
626 * @file - pointer to file object data
627 * @data - pointer to transmit data (one frame)
628 * @count - size of transmit frame in bytes
630 * Returns the number of bytes written (or error code).
632 static ssize_t
n_hdlc_tty_write(struct tty_struct
*tty
, struct file
*file
,
633 const unsigned char *data
, size_t count
)
635 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
637 DECLARE_WAITQUEUE(wait
, current
);
638 struct n_hdlc_buf
*tbuf
;
640 if (debuglevel
>= DEBUG_LEVEL_INFO
)
641 printk("%s(%d)n_hdlc_tty_write() called count=%Zd\n",
642 __FILE__
,__LINE__
,count
);
644 /* Verify pointers */
648 if (n_hdlc
->magic
!= HDLC_MAGIC
)
651 /* verify frame size */
652 if (count
> maxframe
) {
653 if (debuglevel
& DEBUG_LEVEL_INFO
)
655 "n_hdlc_tty_write: truncating user packet "
656 "from %lu to %d\n", (unsigned long) count
,
661 add_wait_queue(&tty
->write_wait
, &wait
);
662 set_current_state(TASK_INTERRUPTIBLE
);
664 /* Allocate transmit buffer */
665 /* sleep until transmit buffer available */
666 while (!(tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_free_buf_list
))) {
669 n_hdlc
= tty2n_hdlc (tty
);
670 if (!n_hdlc
|| n_hdlc
->magic
!= HDLC_MAGIC
||
671 tty
!= n_hdlc
->tty
) {
672 printk("n_hdlc_tty_write: %p invalid after wait!\n", n_hdlc
);
677 if (signal_pending(current
)) {
683 set_current_state(TASK_RUNNING
);
684 remove_wait_queue(&tty
->write_wait
, &wait
);
687 /* Retrieve the user's buffer */
688 memcpy(tbuf
->buf
, data
, count
);
691 tbuf
->count
= error
= count
;
692 n_hdlc_buf_put(&n_hdlc
->tx_buf_list
,tbuf
);
693 n_hdlc_send_frames(n_hdlc
,tty
);
698 } /* end of n_hdlc_tty_write() */
701 * n_hdlc_tty_ioctl - process IOCTL system call for the tty device.
702 * @tty - pointer to tty instance data
703 * @file - pointer to open file object for device
704 * @cmd - IOCTL command code
705 * @arg - argument for IOCTL call (cmd dependent)
707 * Returns command dependent result.
709 static int n_hdlc_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
710 unsigned int cmd
, unsigned long arg
)
712 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
717 if (debuglevel
>= DEBUG_LEVEL_INFO
)
718 printk("%s(%d)n_hdlc_tty_ioctl() called %d\n",
719 __FILE__
,__LINE__
,cmd
);
721 /* Verify the status of the device */
722 if (!n_hdlc
|| n_hdlc
->magic
!= HDLC_MAGIC
)
727 /* report count of read data available */
728 /* in next available frame (if any) */
729 spin_lock_irqsave(&n_hdlc
->rx_buf_list
.spinlock
,flags
);
730 if (n_hdlc
->rx_buf_list
.head
)
731 count
= n_hdlc
->rx_buf_list
.head
->count
;
734 spin_unlock_irqrestore(&n_hdlc
->rx_buf_list
.spinlock
,flags
);
735 error
= put_user(count
, (int __user
*)arg
);
739 /* get the pending tx byte count in the driver */
740 count
= tty
->driver
->chars_in_buffer
?
741 tty
->driver
->chars_in_buffer(tty
) : 0;
742 /* add size of next output frame in queue */
743 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
,flags
);
744 if (n_hdlc
->tx_buf_list
.head
)
745 count
+= n_hdlc
->tx_buf_list
.head
->count
;
746 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
,flags
);
747 error
= put_user(count
, (int __user
*)arg
);
751 error
= n_tty_ioctl (tty
, file
, cmd
, arg
);
756 } /* end of n_hdlc_tty_ioctl() */
759 * n_hdlc_tty_poll - TTY callback for poll system call
760 * @tty - pointer to tty instance data
761 * @filp - pointer to open file object for device
762 * @poll_table - wait queue for operations
764 * Determine which operations (read/write) will not block and return info
766 * Returns a bit mask containing info on which ops will not block.
768 static unsigned int n_hdlc_tty_poll(struct tty_struct
*tty
, struct file
*filp
,
771 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
772 unsigned int mask
= 0;
774 if (debuglevel
>= DEBUG_LEVEL_INFO
)
775 printk("%s(%d)n_hdlc_tty_poll() called\n",__FILE__
,__LINE__
);
777 if (n_hdlc
&& n_hdlc
->magic
== HDLC_MAGIC
&& tty
== n_hdlc
->tty
) {
778 /* queue current process into any wait queue that */
779 /* may awaken in the future (read and write) */
781 poll_wait(filp
, &tty
->read_wait
, wait
);
782 poll_wait(filp
, &tty
->write_wait
, wait
);
784 /* set bits for operations that won't block */
785 if(n_hdlc
->rx_buf_list
.head
)
786 mask
|= POLLIN
| POLLRDNORM
; /* readable */
787 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
))
789 if(tty_hung_up_p(filp
))
791 if(n_hdlc
->tx_free_buf_list
.head
)
792 mask
|= POLLOUT
| POLLWRNORM
; /* writable */
795 } /* end of n_hdlc_tty_poll() */
798 * n_hdlc_alloc - allocate an n_hdlc instance data structure
800 * Returns a pointer to newly created structure if success, otherwise %NULL
802 static struct n_hdlc
*n_hdlc_alloc(void)
804 struct n_hdlc_buf
*buf
;
806 struct n_hdlc
*n_hdlc
= kmalloc(sizeof(*n_hdlc
), GFP_KERNEL
);
811 memset(n_hdlc
, 0, sizeof(*n_hdlc
));
813 n_hdlc_buf_list_init(&n_hdlc
->rx_free_buf_list
);
814 n_hdlc_buf_list_init(&n_hdlc
->tx_free_buf_list
);
815 n_hdlc_buf_list_init(&n_hdlc
->rx_buf_list
);
816 n_hdlc_buf_list_init(&n_hdlc
->tx_buf_list
);
818 /* allocate free rx buffer list */
819 for(i
=0;i
<DEFAULT_RX_BUF_COUNT
;i
++) {
820 buf
= kmalloc(N_HDLC_BUF_SIZE
, GFP_KERNEL
);
822 n_hdlc_buf_put(&n_hdlc
->rx_free_buf_list
,buf
);
823 else if (debuglevel
>= DEBUG_LEVEL_INFO
)
824 printk("%s(%d)n_hdlc_alloc(), kalloc() failed for rx buffer %d\n",__FILE__
,__LINE__
, i
);
827 /* allocate free tx buffer list */
828 for(i
=0;i
<DEFAULT_TX_BUF_COUNT
;i
++) {
829 buf
= kmalloc(N_HDLC_BUF_SIZE
, GFP_KERNEL
);
831 n_hdlc_buf_put(&n_hdlc
->tx_free_buf_list
,buf
);
832 else if (debuglevel
>= DEBUG_LEVEL_INFO
)
833 printk("%s(%d)n_hdlc_alloc(), kalloc() failed for tx buffer %d\n",__FILE__
,__LINE__
, i
);
836 /* Initialize the control block */
837 n_hdlc
->magic
= HDLC_MAGIC
;
842 } /* end of n_hdlc_alloc() */
845 * n_hdlc_buf_list_init - initialize specified HDLC buffer list
846 * @list - pointer to buffer list
848 static void n_hdlc_buf_list_init(struct n_hdlc_buf_list
*list
)
850 memset(list
, 0, sizeof(*list
));
851 spin_lock_init(&list
->spinlock
);
852 } /* end of n_hdlc_buf_list_init() */
855 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list
856 * @list - pointer to buffer list
857 * @buf - pointer to buffer
859 static void n_hdlc_buf_put(struct n_hdlc_buf_list
*list
,
860 struct n_hdlc_buf
*buf
)
863 spin_lock_irqsave(&list
->spinlock
,flags
);
867 list
->tail
->link
= buf
;
873 spin_unlock_irqrestore(&list
->spinlock
,flags
);
875 } /* end of n_hdlc_buf_put() */
878 * n_hdlc_buf_get - remove and return an HDLC buffer from list
879 * @list - pointer to HDLC buffer list
881 * Remove and return an HDLC buffer from the head of the specified HDLC buffer
883 * Returns a pointer to HDLC buffer if available, otherwise %NULL.
885 static struct n_hdlc_buf
* n_hdlc_buf_get(struct n_hdlc_buf_list
*list
)
888 struct n_hdlc_buf
*buf
;
889 spin_lock_irqsave(&list
->spinlock
,flags
);
893 list
->head
= buf
->link
;
899 spin_unlock_irqrestore(&list
->spinlock
,flags
);
902 } /* end of n_hdlc_buf_get() */
904 static char hdlc_banner
[] __initdata
=
905 KERN_INFO
"HDLC line discipline: version " HDLC_VERSION
907 static char hdlc_register_ok
[] __initdata
=
908 KERN_INFO
"N_HDLC line discipline registered.\n";
909 static char hdlc_register_fail
[] __initdata
=
910 KERN_ERR
"error registering line discipline: %d\n";
911 static char hdlc_init_fail
[] __initdata
=
912 KERN_INFO
"N_HDLC: init failure %d\n";
914 static int __init
n_hdlc_init(void)
918 /* range check maxframe arg */
921 else if (maxframe
> 65535)
924 printk(hdlc_banner
, maxframe
);
926 status
= tty_register_ldisc(N_HDLC
, &n_hdlc_ldisc
);
928 printk(hdlc_register_ok
);
930 printk(hdlc_register_fail
, status
);
933 printk(hdlc_init_fail
, status
);
936 } /* end of init_module() */
938 static char hdlc_unregister_ok
[] __exitdata
=
939 KERN_INFO
"N_HDLC: line discipline unregistered\n";
940 static char hdlc_unregister_fail
[] __exitdata
=
941 KERN_ERR
"N_HDLC: can't unregister line discipline (err = %d)\n";
943 static void __exit
n_hdlc_exit(void)
945 /* Release tty registration of line discipline */
946 int status
= tty_unregister_ldisc(N_HDLC
);
949 printk(hdlc_unregister_fail
, status
);
951 printk(hdlc_unregister_ok
);
954 module_init(n_hdlc_init
);
955 module_exit(n_hdlc_exit
);
957 MODULE_LICENSE("GPL");
958 MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com");
959 module_param(debuglevel
, int, 0);
960 module_param(maxframe
, int, 0);
961 MODULE_ALIAS_LDISC(N_HDLC
);