1 // SPDX-License-Identifier: GPL-1.0+
2 /* generic HDLC line discipline for Linux
4 * Written by Paul Fulghum paulkf@microgate.com
5 * for Microgate Corporation
7 * Microgate and SyncLink are registered trademarks of Microgate Corporation
9 * Adapted from ppp.c, written by Michael Callahan <callahan@maths.ox.ac.uk>,
10 * Al Longyear <longyear@netcom.com>,
11 * Paul Mackerras <Paul.Mackerras@cs.anu.edu.au>
13 * Original release 01/11/99
15 * This module implements the tty line discipline N_HDLC for use with
16 * tty device drivers that support bit-synchronous HDLC communications.
18 * All HDLC data is frame oriented which means:
20 * 1. tty write calls represent one complete transmit frame of data
21 * The device driver should accept the complete frame or none of
22 * the frame (busy) in the write method. Each write call should have
23 * a byte count in the range of 2-65535 bytes (2 is min HDLC frame
24 * with 1 addr byte and 1 ctrl byte). The max byte count of 65535
25 * should include any crc bytes required. For example, when using
26 * CCITT CRC32, 4 crc bytes are required, so the maximum size frame
27 * the application may transmit is limited to 65531 bytes. For CCITT
28 * CRC16, the maximum application frame size would be 65533.
31 * 2. receive callbacks from the device driver represents
32 * one received frame. The device driver should bypass
33 * the tty flip buffer and call the line discipline receive
34 * callback directly to avoid fragmenting or concatenating
35 * multiple frames into a single receive callback.
37 * The HDLC line discipline queues the receive frames in separate
38 * buffers so complete receive frames can be returned by the
41 * 3. tty read calls returns an entire frame of data or nothing.
43 * 4. all send and receive data is considered raw. No processing
44 * or translation is performed by the line discipline, regardless
47 * 5. When line discipline is queried for the amount of receive
48 * data available (FIOC), 0 is returned if no data available,
49 * otherwise the count of the next available frame is returned.
50 * (instead of the sum of all received frame counts).
52 * These conventions allow the standard tty programming interface
53 * to be used for synchronous HDLC applications when used with
54 * this line discipline (or another line discipline that is frame
55 * oriented such as N_PPP).
57 * The SyncLink driver (synclink.c) implements both asynchronous
58 * (using standard line discipline N_TTY) and synchronous HDLC
59 * (using N_HDLC) communications, with the latter using the above
62 * This implementation is very basic and does not maintain
63 * any statistics. The main point is to enforce the raw data
64 * and frame orientation of HDLC communications.
66 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
67 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
68 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
69 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
70 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
71 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
72 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
73 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
74 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
75 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
76 * OF THE POSSIBILITY OF SUCH DAMAGE.
79 #define HDLC_MAGIC 0x239e
81 #include <linux/module.h>
82 #include <linux/init.h>
83 #include <linux/kernel.h>
84 #include <linux/sched.h>
85 #include <linux/types.h>
86 #include <linux/fcntl.h>
87 #include <linux/interrupt.h>
88 #include <linux/ptrace.h>
90 #include <linux/poll.h>
92 #include <linux/ioctl.h>
93 #include <linux/slab.h>
94 #include <linux/tty.h>
95 #include <linux/errno.h>
96 #include <linux/string.h> /* used in new tty drivers */
97 #include <linux/signal.h> /* used in new tty drivers */
99 #include <linux/bitops.h>
101 #include <asm/termios.h>
102 #include <linux/uaccess.h>
106 * Buffers for individual HDLC frames
108 #define MAX_HDLC_FRAME_SIZE 65535
109 #define DEFAULT_RX_BUF_COUNT 10
110 #define MAX_RX_BUF_COUNT 60
111 #define DEFAULT_TX_BUF_COUNT 3
114 struct list_head list_item
;
119 struct n_hdlc_buf_list
{
120 struct list_head list
;
126 * struct n_hdlc - per device instance data structure
127 * @magic: magic value for structure
128 * @tbusy: reentrancy flag for tx wakeup code
129 * @woke_up: tx wakeup needs to be run again as it was called while @tbusy
130 * @tx_buf_list: list of pending transmit frame buffers
131 * @rx_buf_list: list of received frame buffers
132 * @tx_free_buf_list: list unused transmit frame buffers
133 * @rx_free_buf_list: list unused received frame buffers
139 struct n_hdlc_buf_list tx_buf_list
;
140 struct n_hdlc_buf_list rx_buf_list
;
141 struct n_hdlc_buf_list tx_free_buf_list
;
142 struct n_hdlc_buf_list rx_free_buf_list
;
146 * HDLC buffer list manipulation functions
148 static void n_hdlc_buf_return(struct n_hdlc_buf_list
*buf_list
,
149 struct n_hdlc_buf
*buf
);
150 static void n_hdlc_buf_put(struct n_hdlc_buf_list
*list
,
151 struct n_hdlc_buf
*buf
);
152 static struct n_hdlc_buf
*n_hdlc_buf_get(struct n_hdlc_buf_list
*list
);
154 /* Local functions */
156 static struct n_hdlc
*n_hdlc_alloc(void);
158 /* max frame size for memory allocations */
159 static int maxframe
= 4096;
161 static void flush_rx_queue(struct tty_struct
*tty
)
163 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
164 struct n_hdlc_buf
*buf
;
166 while ((buf
= n_hdlc_buf_get(&n_hdlc
->rx_buf_list
)))
167 n_hdlc_buf_put(&n_hdlc
->rx_free_buf_list
, buf
);
170 static void flush_tx_queue(struct tty_struct
*tty
)
172 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
173 struct n_hdlc_buf
*buf
;
175 while ((buf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
)))
176 n_hdlc_buf_put(&n_hdlc
->tx_free_buf_list
, buf
);
179 static void n_hdlc_free_buf_list(struct n_hdlc_buf_list
*list
)
181 struct n_hdlc_buf
*buf
;
184 buf
= n_hdlc_buf_get(list
);
190 * n_hdlc_tty_close - line discipline close
191 * @tty: pointer to tty info structure
193 * Called when the line discipline is changed to something
194 * else, the tty is closed, or the tty detects a hangup.
196 static void n_hdlc_tty_close(struct tty_struct
*tty
)
198 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
200 if (n_hdlc
->magic
!= HDLC_MAGIC
) {
201 pr_warn("n_hdlc: trying to close unopened tty!\n");
204 #if defined(TTY_NO_WRITE_SPLIT)
205 clear_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
207 tty
->disc_data
= NULL
;
209 /* Ensure that the n_hdlcd process is not hanging on select()/poll() */
210 wake_up_interruptible(&tty
->read_wait
);
211 wake_up_interruptible(&tty
->write_wait
);
213 n_hdlc_free_buf_list(&n_hdlc
->rx_free_buf_list
);
214 n_hdlc_free_buf_list(&n_hdlc
->tx_free_buf_list
);
215 n_hdlc_free_buf_list(&n_hdlc
->rx_buf_list
);
216 n_hdlc_free_buf_list(&n_hdlc
->tx_buf_list
);
218 } /* end of n_hdlc_tty_close() */
221 * n_hdlc_tty_open - called when line discipline changed to n_hdlc
222 * @tty: pointer to tty info structure
224 * Returns 0 if success, otherwise error code
226 static int n_hdlc_tty_open(struct tty_struct
*tty
)
228 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
230 pr_debug("%s() called (device=%s)\n", __func__
, tty
->name
);
232 /* There should not be an existing table for this slot. */
234 pr_err("%s: tty already associated!\n", __func__
);
238 n_hdlc
= n_hdlc_alloc();
240 pr_err("%s: n_hdlc_alloc failed\n", __func__
);
244 tty
->disc_data
= n_hdlc
;
245 tty
->receive_room
= 65536;
247 /* change tty_io write() to not split large writes into 8K chunks */
248 set_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
250 /* flush receive data from driver */
251 tty_driver_flush_buffer(tty
);
255 } /* end of n_tty_hdlc_open() */
258 * n_hdlc_send_frames - send frames on pending send buffer list
259 * @n_hdlc: pointer to ldisc instance data
260 * @tty: pointer to tty instance data
262 * Send frames on pending send buffer list until the driver does not accept a
263 * frame (busy) this function is called after adding a frame to the send buffer
264 * list and by the tty wakeup callback.
266 static void n_hdlc_send_frames(struct n_hdlc
*n_hdlc
, struct tty_struct
*tty
)
270 struct n_hdlc_buf
*tbuf
;
274 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
276 n_hdlc
->woke_up
= true;
277 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
280 n_hdlc
->tbusy
= true;
281 n_hdlc
->woke_up
= false;
282 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
284 tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
);
286 pr_debug("sending frame %p, count=%d\n", tbuf
, tbuf
->count
);
288 /* Send the next block of data to device */
289 set_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
290 actual
= tty
->ops
->write(tty
, tbuf
->buf
, tbuf
->count
);
292 /* rollback was possible and has been done */
293 if (actual
== -ERESTARTSYS
) {
294 n_hdlc_buf_return(&n_hdlc
->tx_buf_list
, tbuf
);
297 /* if transmit error, throw frame away by */
298 /* pretending it was accepted by driver */
300 actual
= tbuf
->count
;
302 if (actual
== tbuf
->count
) {
303 pr_debug("frame %p completed\n", tbuf
);
305 /* free current transmit buffer */
306 n_hdlc_buf_put(&n_hdlc
->tx_free_buf_list
, tbuf
);
308 /* wait up sleeping writers */
309 wake_up_interruptible(&tty
->write_wait
);
311 /* get next pending transmit buffer */
312 tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_buf_list
);
314 pr_debug("frame %p pending\n", tbuf
);
317 * the buffer was not accepted by driver,
318 * return it back into tx queue
320 n_hdlc_buf_return(&n_hdlc
->tx_buf_list
, tbuf
);
326 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
328 /* Clear the re-entry flag */
329 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
330 n_hdlc
->tbusy
= false;
331 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
335 } /* end of n_hdlc_send_frames() */
338 * n_hdlc_tty_wakeup - Callback for transmit wakeup
339 * @tty: pointer to associated tty instance data
341 * Called when low level device driver can accept more send data.
343 static void n_hdlc_tty_wakeup(struct tty_struct
*tty
)
345 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
347 n_hdlc_send_frames(n_hdlc
, tty
);
348 } /* end of n_hdlc_tty_wakeup() */
351 * n_hdlc_tty_receive - Called by tty driver when receive data is available
352 * @tty: pointer to tty instance data
353 * @data: pointer to received data
354 * @flags: pointer to flags for data
355 * @count: count of received data in bytes
357 * Called by tty low level driver when receive data is available. Data is
358 * interpreted as one HDLC frame.
360 static void n_hdlc_tty_receive(struct tty_struct
*tty
, const __u8
*data
,
361 char *flags
, int count
)
363 register struct n_hdlc
*n_hdlc
= tty
->disc_data
;
364 register struct n_hdlc_buf
*buf
;
366 pr_debug("%s() called count=%d\n", __func__
, count
);
368 /* verify line is using HDLC discipline */
369 if (n_hdlc
->magic
!= HDLC_MAGIC
) {
370 pr_err("line not using HDLC discipline\n");
374 if (count
> maxframe
) {
375 pr_debug("rx count>maxframesize, data discarded\n");
379 /* get a free HDLC buffer */
380 buf
= n_hdlc_buf_get(&n_hdlc
->rx_free_buf_list
);
383 * no buffers in free list, attempt to allocate another rx
384 * buffer unless the maximum count has been reached
386 if (n_hdlc
->rx_buf_list
.count
< MAX_RX_BUF_COUNT
)
387 buf
= kmalloc(struct_size(buf
, buf
, maxframe
),
392 pr_debug("no more rx buffers, data discarded\n");
396 /* copy received data to HDLC buffer */
397 memcpy(buf
->buf
, data
, count
);
400 /* add HDLC buffer to list of received frames */
401 n_hdlc_buf_put(&n_hdlc
->rx_buf_list
, buf
);
403 /* wake up any blocked reads and perform async signalling */
404 wake_up_interruptible(&tty
->read_wait
);
405 if (tty
->fasync
!= NULL
)
406 kill_fasync(&tty
->fasync
, SIGIO
, POLL_IN
);
408 } /* end of n_hdlc_tty_receive() */
411 * n_hdlc_tty_read - Called to retrieve one frame of data (if available)
412 * @tty: pointer to tty instance data
413 * @file: pointer to open file object
414 * @buf: pointer to returned data buffer
415 * @nr: size of returned data buffer
417 * Returns the number of bytes returned or error code.
419 static ssize_t
n_hdlc_tty_read(struct tty_struct
*tty
, struct file
*file
,
420 __u8
*kbuf
, size_t nr
,
421 void **cookie
, unsigned long offset
)
423 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
425 struct n_hdlc_buf
*rbuf
;
426 DECLARE_WAITQUEUE(wait
, current
);
428 /* Is this a repeated call for an rbuf we already found earlier? */
433 add_wait_queue(&tty
->read_wait
, &wait
);
436 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
)) {
440 if (tty_hung_up_p(file
))
443 set_current_state(TASK_INTERRUPTIBLE
);
445 rbuf
= n_hdlc_buf_get(&n_hdlc
->rx_buf_list
);
450 if (tty_io_nonblock(tty
, file
)) {
457 if (signal_pending(current
)) {
463 remove_wait_queue(&tty
->read_wait
, &wait
);
464 __set_current_state(TASK_RUNNING
);
471 /* Have we used it up entirely? */
472 if (offset
>= rbuf
->count
)
475 /* More data to go, but can't copy any more? EOVERFLOW */
480 /* Copy as much data as possible */
481 ret
= rbuf
->count
- offset
;
484 memcpy(kbuf
, rbuf
->buf
+offset
, ret
);
487 /* If we still have data left, we leave the rbuf in the cookie */
488 if (offset
< rbuf
->count
)
494 if (n_hdlc
->rx_free_buf_list
.count
> DEFAULT_RX_BUF_COUNT
)
497 n_hdlc_buf_put(&n_hdlc
->rx_free_buf_list
, rbuf
);
501 } /* end of n_hdlc_tty_read() */
504 * n_hdlc_tty_write - write a single frame of data to device
505 * @tty: pointer to associated tty device instance data
506 * @file: pointer to file object data
507 * @data: pointer to transmit data (one frame)
508 * @count: size of transmit frame in bytes
510 * Returns the number of bytes written (or error code).
512 static ssize_t
n_hdlc_tty_write(struct tty_struct
*tty
, struct file
*file
,
513 const unsigned char *data
, size_t count
)
515 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
517 DECLARE_WAITQUEUE(wait
, current
);
518 struct n_hdlc_buf
*tbuf
;
520 pr_debug("%s() called count=%zd\n", __func__
, count
);
522 if (n_hdlc
->magic
!= HDLC_MAGIC
)
525 /* verify frame size */
526 if (count
> maxframe
) {
527 pr_debug("%s: truncating user packet from %zu to %d\n",
528 __func__
, count
, maxframe
);
532 add_wait_queue(&tty
->write_wait
, &wait
);
535 set_current_state(TASK_INTERRUPTIBLE
);
537 tbuf
= n_hdlc_buf_get(&n_hdlc
->tx_free_buf_list
);
541 if (tty_io_nonblock(tty
, file
)) {
547 if (signal_pending(current
)) {
553 __set_current_state(TASK_RUNNING
);
554 remove_wait_queue(&tty
->write_wait
, &wait
);
557 /* Retrieve the user's buffer */
558 memcpy(tbuf
->buf
, data
, count
);
561 tbuf
->count
= error
= count
;
562 n_hdlc_buf_put(&n_hdlc
->tx_buf_list
, tbuf
);
563 n_hdlc_send_frames(n_hdlc
, tty
);
568 } /* end of n_hdlc_tty_write() */
571 * n_hdlc_tty_ioctl - process IOCTL system call for the tty device.
572 * @tty: pointer to tty instance data
573 * @file: pointer to open file object for device
574 * @cmd: IOCTL command code
575 * @arg: argument for IOCTL call (cmd dependent)
577 * Returns command dependent result.
579 static int n_hdlc_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
580 unsigned int cmd
, unsigned long arg
)
582 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
586 struct n_hdlc_buf
*buf
= NULL
;
588 pr_debug("%s() called %d\n", __func__
, cmd
);
590 /* Verify the status of the device */
591 if (n_hdlc
->magic
!= HDLC_MAGIC
)
596 /* report count of read data available */
597 /* in next available frame (if any) */
598 spin_lock_irqsave(&n_hdlc
->rx_buf_list
.spinlock
, flags
);
599 buf
= list_first_entry_or_null(&n_hdlc
->rx_buf_list
.list
,
600 struct n_hdlc_buf
, list_item
);
605 spin_unlock_irqrestore(&n_hdlc
->rx_buf_list
.spinlock
, flags
);
606 error
= put_user(count
, (int __user
*)arg
);
610 /* get the pending tx byte count in the driver */
611 count
= tty_chars_in_buffer(tty
);
612 /* add size of next output frame in queue */
613 spin_lock_irqsave(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
614 buf
= list_first_entry_or_null(&n_hdlc
->tx_buf_list
.list
,
615 struct n_hdlc_buf
, list_item
);
618 spin_unlock_irqrestore(&n_hdlc
->tx_buf_list
.spinlock
, flags
);
619 error
= put_user(count
, (int __user
*)arg
);
628 fallthrough
; /* to default */
631 error
= n_tty_ioctl_helper(tty
, file
, cmd
, arg
);
636 } /* end of n_hdlc_tty_ioctl() */
639 * n_hdlc_tty_poll - TTY callback for poll system call
640 * @tty: pointer to tty instance data
641 * @filp: pointer to open file object for device
642 * @wait: wait queue for operations
644 * Determine which operations (read/write) will not block and return info
646 * Returns a bit mask containing info on which ops will not block.
648 static __poll_t
n_hdlc_tty_poll(struct tty_struct
*tty
, struct file
*filp
,
651 struct n_hdlc
*n_hdlc
= tty
->disc_data
;
654 if (n_hdlc
->magic
!= HDLC_MAGIC
)
658 * queue the current process into any wait queue that may awaken in the
659 * future (read and write)
661 poll_wait(filp
, &tty
->read_wait
, wait
);
662 poll_wait(filp
, &tty
->write_wait
, wait
);
664 /* set bits for operations that won't block */
665 if (!list_empty(&n_hdlc
->rx_buf_list
.list
))
666 mask
|= EPOLLIN
| EPOLLRDNORM
; /* readable */
667 if (test_bit(TTY_OTHER_CLOSED
, &tty
->flags
))
669 if (tty_hung_up_p(filp
))
671 if (!tty_is_writelocked(tty
) &&
672 !list_empty(&n_hdlc
->tx_free_buf_list
.list
))
673 mask
|= EPOLLOUT
| EPOLLWRNORM
; /* writable */
676 } /* end of n_hdlc_tty_poll() */
678 static void n_hdlc_alloc_buf(struct n_hdlc_buf_list
*list
, unsigned int count
,
681 struct n_hdlc_buf
*buf
;
684 for (i
= 0; i
< count
; i
++) {
685 buf
= kmalloc(struct_size(buf
, buf
, maxframe
), GFP_KERNEL
);
687 pr_debug("%s(), kmalloc() failed for %s buffer %u\n",
691 n_hdlc_buf_put(list
, buf
);
696 * n_hdlc_alloc - allocate an n_hdlc instance data structure
698 * Returns a pointer to newly created structure if success, otherwise %NULL
700 static struct n_hdlc
*n_hdlc_alloc(void)
702 struct n_hdlc
*n_hdlc
= kzalloc(sizeof(*n_hdlc
), GFP_KERNEL
);
707 spin_lock_init(&n_hdlc
->rx_free_buf_list
.spinlock
);
708 spin_lock_init(&n_hdlc
->tx_free_buf_list
.spinlock
);
709 spin_lock_init(&n_hdlc
->rx_buf_list
.spinlock
);
710 spin_lock_init(&n_hdlc
->tx_buf_list
.spinlock
);
712 INIT_LIST_HEAD(&n_hdlc
->rx_free_buf_list
.list
);
713 INIT_LIST_HEAD(&n_hdlc
->tx_free_buf_list
.list
);
714 INIT_LIST_HEAD(&n_hdlc
->rx_buf_list
.list
);
715 INIT_LIST_HEAD(&n_hdlc
->tx_buf_list
.list
);
717 n_hdlc_alloc_buf(&n_hdlc
->rx_free_buf_list
, DEFAULT_RX_BUF_COUNT
, "rx");
718 n_hdlc_alloc_buf(&n_hdlc
->tx_free_buf_list
, DEFAULT_TX_BUF_COUNT
, "tx");
720 /* Initialize the control block */
721 n_hdlc
->magic
= HDLC_MAGIC
;
725 } /* end of n_hdlc_alloc() */
728 * n_hdlc_buf_return - put the HDLC buffer after the head of the specified list
729 * @buf_list: pointer to the buffer list
730 * @buf: pointer to the buffer
732 static void n_hdlc_buf_return(struct n_hdlc_buf_list
*buf_list
,
733 struct n_hdlc_buf
*buf
)
737 spin_lock_irqsave(&buf_list
->spinlock
, flags
);
739 list_add(&buf
->list_item
, &buf_list
->list
);
742 spin_unlock_irqrestore(&buf_list
->spinlock
, flags
);
746 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list
747 * @buf_list: pointer to buffer list
748 * @buf: pointer to buffer
750 static void n_hdlc_buf_put(struct n_hdlc_buf_list
*buf_list
,
751 struct n_hdlc_buf
*buf
)
755 spin_lock_irqsave(&buf_list
->spinlock
, flags
);
757 list_add_tail(&buf
->list_item
, &buf_list
->list
);
760 spin_unlock_irqrestore(&buf_list
->spinlock
, flags
);
761 } /* end of n_hdlc_buf_put() */
764 * n_hdlc_buf_get - remove and return an HDLC buffer from list
765 * @buf_list: pointer to HDLC buffer list
767 * Remove and return an HDLC buffer from the head of the specified HDLC buffer
769 * Returns a pointer to HDLC buffer if available, otherwise %NULL.
771 static struct n_hdlc_buf
*n_hdlc_buf_get(struct n_hdlc_buf_list
*buf_list
)
774 struct n_hdlc_buf
*buf
;
776 spin_lock_irqsave(&buf_list
->spinlock
, flags
);
778 buf
= list_first_entry_or_null(&buf_list
->list
,
779 struct n_hdlc_buf
, list_item
);
781 list_del(&buf
->list_item
);
785 spin_unlock_irqrestore(&buf_list
->spinlock
, flags
);
787 } /* end of n_hdlc_buf_get() */
789 static struct tty_ldisc_ops n_hdlc_ldisc
= {
790 .owner
= THIS_MODULE
,
792 .open
= n_hdlc_tty_open
,
793 .close
= n_hdlc_tty_close
,
794 .read
= n_hdlc_tty_read
,
795 .write
= n_hdlc_tty_write
,
796 .ioctl
= n_hdlc_tty_ioctl
,
797 .poll
= n_hdlc_tty_poll
,
798 .receive_buf
= n_hdlc_tty_receive
,
799 .write_wakeup
= n_hdlc_tty_wakeup
,
800 .flush_buffer
= flush_rx_queue
,
803 static int __init
n_hdlc_init(void)
807 /* range check maxframe arg */
808 maxframe
= clamp(maxframe
, 4096, MAX_HDLC_FRAME_SIZE
);
810 status
= tty_register_ldisc(N_HDLC
, &n_hdlc_ldisc
);
812 pr_info("N_HDLC line discipline registered with maxframe=%d\n",
815 pr_err("N_HDLC: error registering line discipline: %d\n",
820 } /* end of init_module() */
822 static void __exit
n_hdlc_exit(void)
824 /* Release tty registration of line discipline */
825 int status
= tty_unregister_ldisc(N_HDLC
);
828 pr_err("N_HDLC: can't unregister line discipline (err = %d)\n",
831 pr_info("N_HDLC: line discipline unregistered\n");
834 module_init(n_hdlc_init
);
835 module_exit(n_hdlc_exit
);
837 MODULE_LICENSE("GPL");
838 MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com");
839 module_param(maxframe
, int, 0);
840 MODULE_ALIAS_LDISC(N_HDLC
);