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 .receive_room
= n_hdlc_tty_room
,
216 .write_wakeup
= n_hdlc_tty_wakeup
,
220 * n_hdlc_release - release an n_hdlc per device line discipline info structure
221 * @n_hdlc - per device line discipline info structure
223 static void n_hdlc_release(struct n_hdlc
*n_hdlc
)
225 struct tty_struct
*tty
= n_hdlc2tty (n_hdlc
);
226 struct n_hdlc_buf
*buf
;
228 if (debuglevel
>= DEBUG_LEVEL_INFO
)
229 printk("%s(%d)n_hdlc_release() called\n",__FILE__
,__LINE__
);
231 /* Ensure that the n_hdlcd process is not hanging on select()/poll() */
232 wake_up_interruptible (&tty
->read_wait
);
233 wake_up_interruptible (&tty
->write_wait
);
235 if (tty
!= NULL
&& tty
->disc_data
== n_hdlc
)
236 tty
->disc_data
= NULL
; /* Break the tty->n_hdlc link */
238 /* Release transmit and receive buffers */
240 buf
= n_hdlc_buf_get(&n_hdlc
->rx_free_buf_list
);
247 buf
= n_hdlc_buf_get(&n_hdlc
->tx_free_buf_list
);
254 buf
= n_hdlc_buf_get(&n_hdlc
->rx_buf_list
);
261 buf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
);
270 } /* end of n_hdlc_release() */
273 * n_hdlc_tty_close - line discipline close
274 * @tty - pointer to tty info structure
276 * Called when the line discipline is changed to something
277 * else, the tty is closed, or the tty detects a hangup.
279 static void n_hdlc_tty_close(struct tty_struct
*tty
)
281 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
283 if (debuglevel
>= DEBUG_LEVEL_INFO
)
284 printk("%s(%d)n_hdlc_tty_close() called\n",__FILE__
,__LINE__
);
286 if (n_hdlc
!= NULL
) {
287 if (n_hdlc
->magic
!= HDLC_MAGIC
) {
288 printk (KERN_WARNING
"n_hdlc: trying to close unopened tty!\n");
291 #if defined(TTY_NO_WRITE_SPLIT)
292 clear_bit(TTY_NO_WRITE_SPLIT
,&tty
->flags
);
294 tty
->disc_data
= NULL
;
295 if (tty
== n_hdlc
->backup_tty
)
296 n_hdlc
->backup_tty
= NULL
;
297 if (tty
!= n_hdlc
->tty
)
299 if (n_hdlc
->backup_tty
) {
300 n_hdlc
->tty
= n_hdlc
->backup_tty
;
302 n_hdlc_release (n_hdlc
);
306 if (debuglevel
>= DEBUG_LEVEL_INFO
)
307 printk("%s(%d)n_hdlc_tty_close() success\n",__FILE__
,__LINE__
);
309 } /* end of n_hdlc_tty_close() */
312 * n_hdlc_tty_open - called when line discipline changed to n_hdlc
313 * @tty - pointer to tty info structure
315 * Returns 0 if success, otherwise error code
317 static int n_hdlc_tty_open (struct tty_struct
*tty
)
319 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
321 if (debuglevel
>= DEBUG_LEVEL_INFO
)
322 printk("%s(%d)n_hdlc_tty_open() called (device=%s)\n",
326 /* There should not be an existing table for this slot. */
328 printk (KERN_ERR
"n_hdlc_tty_open:tty already associated!\n" );
332 n_hdlc
= n_hdlc_alloc();
334 printk (KERN_ERR
"n_hdlc_alloc failed\n");
338 tty
->disc_data
= n_hdlc
;
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_room - Return the amount of space left in the receiver's buffer
482 * @tty - pointer to associated tty instance data
484 * Callback function from tty driver. Return the amount of space left in the
485 * receiver's buffer to decide if remote transmitter is to be throttled.
487 static int n_hdlc_tty_room(struct tty_struct
*tty
)
489 if (debuglevel
>= DEBUG_LEVEL_INFO
)
490 printk("%s(%d)n_hdlc_tty_room() called\n",__FILE__
,__LINE__
);
491 /* always return a larger number to prevent */
492 /* throttling of remote transmitter. */
494 } /* end of n_hdlc_tty_root() */
497 * n_hdlc_tty_receive - Called by tty driver when receive data is available
498 * @tty - pointer to tty instance data
499 * @data - pointer to received data
500 * @flags - pointer to flags for data
501 * @count - count of received data in bytes
503 * Called by tty low level driver when receive data is available. Data is
504 * interpreted as one HDLC frame.
506 static void n_hdlc_tty_receive(struct tty_struct
*tty
, const __u8
*data
,
507 char *flags
, int count
)
509 register struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
510 register struct n_hdlc_buf
*buf
;
512 if (debuglevel
>= DEBUG_LEVEL_INFO
)
513 printk("%s(%d)n_hdlc_tty_receive() called count=%d\n",
514 __FILE__
,__LINE__
, count
);
516 /* This can happen if stuff comes in on the backup tty */
517 if (n_hdlc
== 0 || tty
!= n_hdlc
->tty
)
520 /* verify line is using HDLC discipline */
521 if (n_hdlc
->magic
!= HDLC_MAGIC
) {
522 printk("%s(%d) line not using HDLC discipline\n",
527 if ( count
>maxframe
) {
528 if (debuglevel
>= DEBUG_LEVEL_INFO
)
529 printk("%s(%d) rx count>maxframesize, data discarded\n",
534 /* get a free HDLC buffer */
535 buf
= n_hdlc_buf_get(&n_hdlc
->rx_free_buf_list
);
537 /* no buffers in free list, attempt to allocate another rx buffer */
538 /* unless the maximum count has been reached */
539 if (n_hdlc
->rx_buf_list
.count
< MAX_RX_BUF_COUNT
)
540 buf
= kmalloc(N_HDLC_BUF_SIZE
, GFP_ATOMIC
);
544 if (debuglevel
>= DEBUG_LEVEL_INFO
)
545 printk("%s(%d) no more rx buffers, data discarded\n",
550 /* copy received data to HDLC buffer */
551 memcpy(buf
->buf
,data
,count
);
554 /* add HDLC buffer to list of received frames */
555 n_hdlc_buf_put(&n_hdlc
->rx_buf_list
, buf
);
557 /* wake up any blocked reads and perform async signalling */
558 wake_up_interruptible (&tty
->read_wait
);
559 if (n_hdlc
->tty
->fasync
!= NULL
)
560 kill_fasync (&n_hdlc
->tty
->fasync
, SIGIO
, POLL_IN
);
562 } /* end of n_hdlc_tty_receive() */
565 * n_hdlc_tty_read - Called to retrieve one frame of data (if available)
566 * @tty - pointer to tty instance data
567 * @file - pointer to open file object
568 * @buf - pointer to returned data buffer
569 * @nr - size of returned data buffer
571 * Returns the number of bytes returned or error code.
573 static ssize_t
n_hdlc_tty_read(struct tty_struct
*tty
, struct file
*file
,
574 __u8 __user
*buf
, size_t nr
)
576 struct n_hdlc
*n_hdlc
= tty2n_hdlc(tty
);
578 struct n_hdlc_buf
*rbuf
;
580 if (debuglevel
>= DEBUG_LEVEL_INFO
)
581 printk("%s(%d)n_hdlc_tty_read() called\n",__FILE__
,__LINE__
);
583 /* Validate the pointers */
587 /* verify user access to buffer */
588 if (!access_ok(VERIFY_WRITE
, buf
, nr
)) {
589 printk(KERN_WARNING
"%s(%d) n_hdlc_tty_read() can't verify user "
590 "buffer\n", __FILE__
, __LINE__
);
595 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
))
598 n_hdlc
= tty2n_hdlc (tty
);
599 if (!n_hdlc
|| n_hdlc
->magic
!= HDLC_MAGIC
||
603 rbuf
= n_hdlc_buf_get(&n_hdlc
->rx_buf_list
);
608 if (file
->f_flags
& O_NONBLOCK
)
611 interruptible_sleep_on (&tty
->read_wait
);
612 if (signal_pending(current
))
616 if (rbuf
->count
> nr
)
617 /* frame too large for caller's buffer (discard frame) */
620 /* Copy the data to the caller's buffer */
621 if (copy_to_user(buf
, rbuf
->buf
, rbuf
->count
))
627 /* return HDLC buffer to free list unless the free list */
628 /* count has exceeded the default value, in which case the */
629 /* buffer is freed back to the OS to conserve memory */
630 if (n_hdlc
->rx_free_buf_list
.count
> DEFAULT_RX_BUF_COUNT
)
633 n_hdlc_buf_put(&n_hdlc
->rx_free_buf_list
,rbuf
);
637 } /* end of n_hdlc_tty_read() */
640 * n_hdlc_tty_write - write a single frame of data to device
641 * @tty - pointer to associated tty device instance data
642 * @file - pointer to file object data
643 * @data - pointer to transmit data (one frame)
644 * @count - size of transmit frame in bytes
646 * Returns the number of bytes written (or error code).
648 static ssize_t
n_hdlc_tty_write(struct tty_struct
*tty
, struct file
*file
,
649 const unsigned char *data
, size_t count
)
651 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
653 DECLARE_WAITQUEUE(wait
, current
);
654 struct n_hdlc_buf
*tbuf
;
656 if (debuglevel
>= DEBUG_LEVEL_INFO
)
657 printk("%s(%d)n_hdlc_tty_write() called count=%Zd\n",
658 __FILE__
,__LINE__
,count
);
660 /* Verify pointers */
664 if (n_hdlc
->magic
!= HDLC_MAGIC
)
667 /* verify frame size */
668 if (count
> maxframe
) {
669 if (debuglevel
& DEBUG_LEVEL_INFO
)
671 "n_hdlc_tty_write: truncating user packet "
672 "from %lu to %d\n", (unsigned long) count
,
677 add_wait_queue(&tty
->write_wait
, &wait
);
678 set_current_state(TASK_INTERRUPTIBLE
);
680 /* Allocate transmit buffer */
681 /* sleep until transmit buffer available */
682 while (!(tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_free_buf_list
))) {
685 n_hdlc
= tty2n_hdlc (tty
);
686 if (!n_hdlc
|| n_hdlc
->magic
!= HDLC_MAGIC
||
687 tty
!= n_hdlc
->tty
) {
688 printk("n_hdlc_tty_write: %p invalid after wait!\n", n_hdlc
);
693 if (signal_pending(current
)) {
699 set_current_state(TASK_RUNNING
);
700 remove_wait_queue(&tty
->write_wait
, &wait
);
703 /* Retrieve the user's buffer */
704 memcpy(tbuf
->buf
, data
, count
);
707 tbuf
->count
= error
= count
;
708 n_hdlc_buf_put(&n_hdlc
->tx_buf_list
,tbuf
);
709 n_hdlc_send_frames(n_hdlc
,tty
);
714 } /* end of n_hdlc_tty_write() */
717 * n_hdlc_tty_ioctl - process IOCTL system call for the tty device.
718 * @tty - pointer to tty instance data
719 * @file - pointer to open file object for device
720 * @cmd - IOCTL command code
721 * @arg - argument for IOCTL call (cmd dependent)
723 * Returns command dependent result.
725 static int n_hdlc_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
726 unsigned int cmd
, unsigned long arg
)
728 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
733 if (debuglevel
>= DEBUG_LEVEL_INFO
)
734 printk("%s(%d)n_hdlc_tty_ioctl() called %d\n",
735 __FILE__
,__LINE__
,cmd
);
737 /* Verify the status of the device */
738 if (!n_hdlc
|| n_hdlc
->magic
!= HDLC_MAGIC
)
743 /* report count of read data available */
744 /* in next available frame (if any) */
745 spin_lock_irqsave(&n_hdlc
->rx_buf_list
.spinlock
,flags
);
746 if (n_hdlc
->rx_buf_list
.head
)
747 count
= n_hdlc
->rx_buf_list
.head
->count
;
750 spin_unlock_irqrestore(&n_hdlc
->rx_buf_list
.spinlock
,flags
);
751 error
= put_user(count
, (int __user
*)arg
);
755 /* get the pending tx byte count in the driver */
756 count
= tty
->driver
->chars_in_buffer
?
757 tty
->driver
->chars_in_buffer(tty
) : 0;
758 /* add size of next output frame in queue */
759 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
,flags
);
760 if (n_hdlc
->tx_buf_list
.head
)
761 count
+= n_hdlc
->tx_buf_list
.head
->count
;
762 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
,flags
);
763 error
= put_user(count
, (int __user
*)arg
);
767 error
= n_tty_ioctl (tty
, file
, cmd
, arg
);
772 } /* end of n_hdlc_tty_ioctl() */
775 * n_hdlc_tty_poll - TTY callback for poll system call
776 * @tty - pointer to tty instance data
777 * @filp - pointer to open file object for device
778 * @poll_table - wait queue for operations
780 * Determine which operations (read/write) will not block and return info
782 * Returns a bit mask containing info on which ops will not block.
784 static unsigned int n_hdlc_tty_poll(struct tty_struct
*tty
, struct file
*filp
,
787 struct n_hdlc
*n_hdlc
= tty2n_hdlc (tty
);
788 unsigned int mask
= 0;
790 if (debuglevel
>= DEBUG_LEVEL_INFO
)
791 printk("%s(%d)n_hdlc_tty_poll() called\n",__FILE__
,__LINE__
);
793 if (n_hdlc
&& n_hdlc
->magic
== HDLC_MAGIC
&& tty
== n_hdlc
->tty
) {
794 /* queue current process into any wait queue that */
795 /* may awaken in the future (read and write) */
797 poll_wait(filp
, &tty
->read_wait
, wait
);
798 poll_wait(filp
, &tty
->write_wait
, wait
);
800 /* set bits for operations that won't block */
801 if(n_hdlc
->rx_buf_list
.head
)
802 mask
|= POLLIN
| POLLRDNORM
; /* readable */
803 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
))
805 if(tty_hung_up_p(filp
))
807 if(n_hdlc
->tx_free_buf_list
.head
)
808 mask
|= POLLOUT
| POLLWRNORM
; /* writable */
811 } /* end of n_hdlc_tty_poll() */
814 * n_hdlc_alloc - allocate an n_hdlc instance data structure
816 * Returns a pointer to newly created structure if success, otherwise %NULL
818 static struct n_hdlc
*n_hdlc_alloc(void)
820 struct n_hdlc_buf
*buf
;
822 struct n_hdlc
*n_hdlc
= kmalloc(sizeof(*n_hdlc
), GFP_KERNEL
);
827 memset(n_hdlc
, 0, sizeof(*n_hdlc
));
829 n_hdlc_buf_list_init(&n_hdlc
->rx_free_buf_list
);
830 n_hdlc_buf_list_init(&n_hdlc
->tx_free_buf_list
);
831 n_hdlc_buf_list_init(&n_hdlc
->rx_buf_list
);
832 n_hdlc_buf_list_init(&n_hdlc
->tx_buf_list
);
834 /* allocate free rx buffer list */
835 for(i
=0;i
<DEFAULT_RX_BUF_COUNT
;i
++) {
836 buf
= kmalloc(N_HDLC_BUF_SIZE
, GFP_KERNEL
);
838 n_hdlc_buf_put(&n_hdlc
->rx_free_buf_list
,buf
);
839 else if (debuglevel
>= DEBUG_LEVEL_INFO
)
840 printk("%s(%d)n_hdlc_alloc(), kalloc() failed for rx buffer %d\n",__FILE__
,__LINE__
, i
);
843 /* allocate free tx buffer list */
844 for(i
=0;i
<DEFAULT_TX_BUF_COUNT
;i
++) {
845 buf
= kmalloc(N_HDLC_BUF_SIZE
, GFP_KERNEL
);
847 n_hdlc_buf_put(&n_hdlc
->tx_free_buf_list
,buf
);
848 else if (debuglevel
>= DEBUG_LEVEL_INFO
)
849 printk("%s(%d)n_hdlc_alloc(), kalloc() failed for tx buffer %d\n",__FILE__
,__LINE__
, i
);
852 /* Initialize the control block */
853 n_hdlc
->magic
= HDLC_MAGIC
;
858 } /* end of n_hdlc_alloc() */
861 * n_hdlc_buf_list_init - initialize specified HDLC buffer list
862 * @list - pointer to buffer list
864 static void n_hdlc_buf_list_init(struct n_hdlc_buf_list
*list
)
866 memset(list
, 0, sizeof(*list
));
867 spin_lock_init(&list
->spinlock
);
868 } /* end of n_hdlc_buf_list_init() */
871 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list
872 * @list - pointer to buffer list
873 * @buf - pointer to buffer
875 static void n_hdlc_buf_put(struct n_hdlc_buf_list
*list
,
876 struct n_hdlc_buf
*buf
)
879 spin_lock_irqsave(&list
->spinlock
,flags
);
883 list
->tail
->link
= buf
;
889 spin_unlock_irqrestore(&list
->spinlock
,flags
);
891 } /* end of n_hdlc_buf_put() */
894 * n_hdlc_buf_get - remove and return an HDLC buffer from list
895 * @list - pointer to HDLC buffer list
897 * Remove and return an HDLC buffer from the head of the specified HDLC buffer
899 * Returns a pointer to HDLC buffer if available, otherwise %NULL.
901 static struct n_hdlc_buf
* n_hdlc_buf_get(struct n_hdlc_buf_list
*list
)
904 struct n_hdlc_buf
*buf
;
905 spin_lock_irqsave(&list
->spinlock
,flags
);
909 list
->head
= buf
->link
;
915 spin_unlock_irqrestore(&list
->spinlock
,flags
);
918 } /* end of n_hdlc_buf_get() */
920 static char hdlc_banner
[] __initdata
=
921 KERN_INFO
"HDLC line discipline: version " HDLC_VERSION
923 static char hdlc_register_ok
[] __initdata
=
924 KERN_INFO
"N_HDLC line discipline registered.\n";
925 static char hdlc_register_fail
[] __initdata
=
926 KERN_ERR
"error registering line discipline: %d\n";
927 static char hdlc_init_fail
[] __initdata
=
928 KERN_INFO
"N_HDLC: init failure %d\n";
930 static int __init
n_hdlc_init(void)
934 /* range check maxframe arg */
937 else if (maxframe
> 65535)
940 printk(hdlc_banner
, maxframe
);
942 status
= tty_register_ldisc(N_HDLC
, &n_hdlc_ldisc
);
944 printk(hdlc_register_ok
);
946 printk(hdlc_register_fail
, status
);
949 printk(hdlc_init_fail
, status
);
952 } /* end of init_module() */
954 static char hdlc_unregister_ok
[] __exitdata
=
955 KERN_INFO
"N_HDLC: line discipline unregistered\n";
956 static char hdlc_unregister_fail
[] __exitdata
=
957 KERN_ERR
"N_HDLC: can't unregister line discipline (err = %d)\n";
959 static void __exit
n_hdlc_exit(void)
961 /* Release tty registration of line discipline */
962 int status
= tty_unregister_ldisc(N_HDLC
);
965 printk(hdlc_unregister_fail
, status
);
967 printk(hdlc_unregister_ok
);
970 module_init(n_hdlc_init
);
971 module_exit(n_hdlc_exit
);
973 MODULE_LICENSE("GPL");
974 MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com");
975 module_param(debuglevel
, int, 0);
976 module_param(maxframe
, int, 0);
977 MODULE_ALIAS_LDISC(N_HDLC
);