GNU Linux-libre 5.13.14-gnu1
[releases.git] / drivers / tty / n_hdlc.c
1 // SPDX-License-Identifier: GPL-1.0+
2 /* generic HDLC line discipline for Linux
3  *
4  * Written by Paul Fulghum paulkf@microgate.com
5  * for Microgate Corporation
6  *
7  * Microgate and SyncLink are registered trademarks of Microgate Corporation
8  *
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>
12  *
13  * Original release 01/11/99
14  *
15  * This module implements the tty line discipline N_HDLC for use with
16  * tty device drivers that support bit-synchronous HDLC communications.
17  *
18  * All HDLC data is frame oriented which means:
19  *
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.
29  *
30  *
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.
36  *
37  *    The HDLC line discipline queues the receive frames in separate
38  *    buffers so complete receive frames can be returned by the
39  *    tty read calls.
40  *
41  * 3. tty read calls returns an entire frame of data or nothing.
42  *
43  * 4. all send and receive data is considered raw. No processing
44  *    or translation is performed by the line discipline, regardless
45  *    of the tty flags
46  *
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).
51  *
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).
56  *
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
60  * conventions.
61  *
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.
65  *
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.
77  */
78
79 #define HDLC_MAGIC 0x239e
80
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>
89
90 #include <linux/poll.h>
91 #include <linux/in.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 */
98 #include <linux/if.h>
99 #include <linux/bitops.h>
100
101 #include <asm/termios.h>
102 #include <linux/uaccess.h>
103 #include "tty.h"
104
105 /*
106  * Buffers for individual HDLC frames
107  */
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
112
113 struct n_hdlc_buf {
114         struct list_head  list_item;
115         int               count;
116         char              buf[];
117 };
118
119 struct n_hdlc_buf_list {
120         struct list_head  list;
121         int               count;
122         spinlock_t        spinlock;
123 };
124
125 /**
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
134  */
135 struct n_hdlc {
136         int                     magic;
137         bool                    tbusy;
138         bool                    woke_up;
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;
143 };
144
145 /*
146  * HDLC buffer list manipulation functions
147  */
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);
153
154 /* Local functions */
155
156 static struct n_hdlc *n_hdlc_alloc(void);
157
158 /* max frame size for memory allocations */
159 static int maxframe = 4096;
160
161 static void flush_rx_queue(struct tty_struct *tty)
162 {
163         struct n_hdlc *n_hdlc = tty->disc_data;
164         struct n_hdlc_buf *buf;
165
166         while ((buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list)))
167                 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, buf);
168 }
169
170 static void flush_tx_queue(struct tty_struct *tty)
171 {
172         struct n_hdlc *n_hdlc = tty->disc_data;
173         struct n_hdlc_buf *buf;
174
175         while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list)))
176                 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf);
177 }
178
179 static void n_hdlc_free_buf_list(struct n_hdlc_buf_list *list)
180 {
181         struct n_hdlc_buf *buf;
182
183         do {
184                 buf = n_hdlc_buf_get(list);
185                 kfree(buf);
186         } while (buf);
187 }
188
189 /**
190  * n_hdlc_tty_close - line discipline close
191  * @tty: pointer to tty info structure
192  *
193  * Called when the line discipline is changed to something
194  * else, the tty is closed, or the tty detects a hangup.
195  */
196 static void n_hdlc_tty_close(struct tty_struct *tty)
197 {
198         struct n_hdlc *n_hdlc = tty->disc_data;
199
200         if (n_hdlc->magic != HDLC_MAGIC) {
201                 pr_warn("n_hdlc: trying to close unopened tty!\n");
202                 return;
203         }
204 #if defined(TTY_NO_WRITE_SPLIT)
205         clear_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
206 #endif
207         tty->disc_data = NULL;
208
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);
212
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);
217         kfree(n_hdlc);
218 }       /* end of n_hdlc_tty_close() */
219
220 /**
221  * n_hdlc_tty_open - called when line discipline changed to n_hdlc
222  * @tty: pointer to tty info structure
223  *
224  * Returns 0 if success, otherwise error code
225  */
226 static int n_hdlc_tty_open(struct tty_struct *tty)
227 {
228         struct n_hdlc *n_hdlc = tty->disc_data;
229
230         pr_debug("%s() called (device=%s)\n", __func__, tty->name);
231
232         /* There should not be an existing table for this slot. */
233         if (n_hdlc) {
234                 pr_err("%s: tty already associated!\n", __func__);
235                 return -EEXIST;
236         }
237
238         n_hdlc = n_hdlc_alloc();
239         if (!n_hdlc) {
240                 pr_err("%s: n_hdlc_alloc failed\n", __func__);
241                 return -ENFILE;
242         }
243
244         tty->disc_data = n_hdlc;
245         tty->receive_room = 65536;
246
247         /* change tty_io write() to not split large writes into 8K chunks */
248         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
249
250         /* flush receive data from driver */
251         tty_driver_flush_buffer(tty);
252
253         return 0;
254
255 }       /* end of n_tty_hdlc_open() */
256
257 /**
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
261  *
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.
265  */
266 static void n_hdlc_send_frames(struct n_hdlc *n_hdlc, struct tty_struct *tty)
267 {
268         register int actual;
269         unsigned long flags;
270         struct n_hdlc_buf *tbuf;
271
272 check_again:
273
274         spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);
275         if (n_hdlc->tbusy) {
276                 n_hdlc->woke_up = true;
277                 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
278                 return;
279         }
280         n_hdlc->tbusy = true;
281         n_hdlc->woke_up = false;
282         spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
283
284         tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
285         while (tbuf) {
286                 pr_debug("sending frame %p, count=%d\n", tbuf, tbuf->count);
287
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);
291
292                 /* rollback was possible and has been done */
293                 if (actual == -ERESTARTSYS) {
294                         n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf);
295                         break;
296                 }
297                 /* if transmit error, throw frame away by */
298                 /* pretending it was accepted by driver */
299                 if (actual < 0)
300                         actual = tbuf->count;
301
302                 if (actual == tbuf->count) {
303                         pr_debug("frame %p completed\n", tbuf);
304
305                         /* free current transmit buffer */
306                         n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, tbuf);
307
308                         /* wait up sleeping writers */
309                         wake_up_interruptible(&tty->write_wait);
310
311                         /* get next pending transmit buffer */
312                         tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
313                 } else {
314                         pr_debug("frame %p pending\n", tbuf);
315
316                         /*
317                          * the buffer was not accepted by driver,
318                          * return it back into tx queue
319                          */
320                         n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf);
321                         break;
322                 }
323         }
324
325         if (!tbuf)
326                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
327
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);
332
333         if (n_hdlc->woke_up)
334                 goto check_again;
335 }       /* end of n_hdlc_send_frames() */
336
337 /**
338  * n_hdlc_tty_wakeup - Callback for transmit wakeup
339  * @tty: pointer to associated tty instance data
340  *
341  * Called when low level device driver can accept more send data.
342  */
343 static void n_hdlc_tty_wakeup(struct tty_struct *tty)
344 {
345         struct n_hdlc *n_hdlc = tty->disc_data;
346
347         n_hdlc_send_frames(n_hdlc, tty);
348 }       /* end of n_hdlc_tty_wakeup() */
349
350 /**
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
356  *
357  * Called by tty low level driver when receive data is available. Data is
358  * interpreted as one HDLC frame.
359  */
360 static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data,
361                                char *flags, int count)
362 {
363         register struct n_hdlc *n_hdlc = tty->disc_data;
364         register struct n_hdlc_buf *buf;
365
366         pr_debug("%s() called count=%d\n", __func__, count);
367
368         /* verify line is using HDLC discipline */
369         if (n_hdlc->magic != HDLC_MAGIC) {
370                 pr_err("line not using HDLC discipline\n");
371                 return;
372         }
373
374         if (count > maxframe) {
375                 pr_debug("rx count>maxframesize, data discarded\n");
376                 return;
377         }
378
379         /* get a free HDLC buffer */
380         buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);
381         if (!buf) {
382                 /*
383                  * no buffers in free list, attempt to allocate another rx
384                  * buffer unless the maximum count has been reached
385                  */
386                 if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT)
387                         buf = kmalloc(struct_size(buf, buf, maxframe),
388                                       GFP_ATOMIC);
389         }
390
391         if (!buf) {
392                 pr_debug("no more rx buffers, data discarded\n");
393                 return;
394         }
395
396         /* copy received data to HDLC buffer */
397         memcpy(buf->buf, data, count);
398         buf->count = count;
399
400         /* add HDLC buffer to list of received frames */
401         n_hdlc_buf_put(&n_hdlc->rx_buf_list, buf);
402
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);
407
408 }       /* end of n_hdlc_tty_receive() */
409
410 /**
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
416  *
417  * Returns the number of bytes returned or error code.
418  */
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)
422 {
423         struct n_hdlc *n_hdlc = tty->disc_data;
424         int ret = 0;
425         struct n_hdlc_buf *rbuf;
426         DECLARE_WAITQUEUE(wait, current);
427
428         /* Is this a repeated call for an rbuf we already found earlier? */
429         rbuf = *cookie;
430         if (rbuf)
431                 goto have_rbuf;
432
433         add_wait_queue(&tty->read_wait, &wait);
434
435         for (;;) {
436                 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
437                         ret = -EIO;
438                         break;
439                 }
440                 if (tty_hung_up_p(file))
441                         break;
442
443                 set_current_state(TASK_INTERRUPTIBLE);
444
445                 rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);
446                 if (rbuf)
447                         break;
448
449                 /* no data */
450                 if (tty_io_nonblock(tty, file)) {
451                         ret = -EAGAIN;
452                         break;
453                 }
454
455                 schedule();
456
457                 if (signal_pending(current)) {
458                         ret = -EINTR;
459                         break;
460                 }
461         }
462
463         remove_wait_queue(&tty->read_wait, &wait);
464         __set_current_state(TASK_RUNNING);
465
466         if (!rbuf)
467                 return ret;
468         *cookie = rbuf;
469
470 have_rbuf:
471         /* Have we used it up entirely? */
472         if (offset >= rbuf->count)
473                 goto done_with_rbuf;
474
475         /* More data to go, but can't copy any more? EOVERFLOW */
476         ret = -EOVERFLOW;
477         if (!nr)
478                 goto done_with_rbuf;
479
480         /* Copy as much data as possible */
481         ret = rbuf->count - offset;
482         if (ret > nr)
483                 ret = nr;
484         memcpy(kbuf, rbuf->buf+offset, ret);
485         offset += ret;
486
487         /* If we still have data left, we leave the rbuf in the cookie */
488         if (offset < rbuf->count)
489                 return ret;
490
491 done_with_rbuf:
492         *cookie = NULL;
493
494         if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT)
495                 kfree(rbuf);
496         else
497                 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, rbuf);
498
499         return ret;
500
501 }       /* end of n_hdlc_tty_read() */
502
503 /**
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
509  *
510  * Returns the number of bytes written (or error code).
511  */
512 static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file,
513                             const unsigned char *data, size_t count)
514 {
515         struct n_hdlc *n_hdlc = tty->disc_data;
516         int error = 0;
517         DECLARE_WAITQUEUE(wait, current);
518         struct n_hdlc_buf *tbuf;
519
520         pr_debug("%s() called count=%zd\n", __func__, count);
521
522         if (n_hdlc->magic != HDLC_MAGIC)
523                 return -EIO;
524
525         /* verify frame size */
526         if (count > maxframe) {
527                 pr_debug("%s: truncating user packet from %zu to %d\n",
528                                 __func__, count, maxframe);
529                 count = maxframe;
530         }
531
532         add_wait_queue(&tty->write_wait, &wait);
533
534         for (;;) {
535                 set_current_state(TASK_INTERRUPTIBLE);
536
537                 tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list);
538                 if (tbuf)
539                         break;
540
541                 if (tty_io_nonblock(tty, file)) {
542                         error = -EAGAIN;
543                         break;
544                 }
545                 schedule();
546
547                 if (signal_pending(current)) {
548                         error = -EINTR;
549                         break;
550                 }
551         }
552
553         __set_current_state(TASK_RUNNING);
554         remove_wait_queue(&tty->write_wait, &wait);
555
556         if (!error) {
557                 /* Retrieve the user's buffer */
558                 memcpy(tbuf->buf, data, count);
559
560                 /* Send the data */
561                 tbuf->count = error = count;
562                 n_hdlc_buf_put(&n_hdlc->tx_buf_list, tbuf);
563                 n_hdlc_send_frames(n_hdlc, tty);
564         }
565
566         return error;
567
568 }       /* end of n_hdlc_tty_write() */
569
570 /**
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)
576  *
577  * Returns command dependent result.
578  */
579 static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file,
580                             unsigned int cmd, unsigned long arg)
581 {
582         struct n_hdlc *n_hdlc = tty->disc_data;
583         int error = 0;
584         int count;
585         unsigned long flags;
586         struct n_hdlc_buf *buf = NULL;
587
588         pr_debug("%s() called %d\n", __func__, cmd);
589
590         /* Verify the status of the device */
591         if (n_hdlc->magic != HDLC_MAGIC)
592                 return -EBADF;
593
594         switch (cmd) {
595         case FIONREAD:
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);
601                 if (buf)
602                         count = buf->count;
603                 else
604                         count = 0;
605                 spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock, flags);
606                 error = put_user(count, (int __user *)arg);
607                 break;
608
609         case TIOCOUTQ:
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);
616                 if (buf)
617                         count += buf->count;
618                 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
619                 error = put_user(count, (int __user *)arg);
620                 break;
621
622         case TCFLSH:
623                 switch (arg) {
624                 case TCIOFLUSH:
625                 case TCOFLUSH:
626                         flush_tx_queue(tty);
627                 }
628                 fallthrough;    /* to default */
629
630         default:
631                 error = n_tty_ioctl_helper(tty, file, cmd, arg);
632                 break;
633         }
634         return error;
635
636 }       /* end of n_hdlc_tty_ioctl() */
637
638 /**
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
643  *
644  * Determine which operations (read/write) will not block and return info
645  * to caller.
646  * Returns a bit mask containing info on which ops will not block.
647  */
648 static __poll_t n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,
649                                     poll_table *wait)
650 {
651         struct n_hdlc *n_hdlc = tty->disc_data;
652         __poll_t mask = 0;
653
654         if (n_hdlc->magic != HDLC_MAGIC)
655                 return 0;
656
657         /*
658          * queue the current process into any wait queue that may awaken in the
659          * future (read and write)
660          */
661         poll_wait(filp, &tty->read_wait, wait);
662         poll_wait(filp, &tty->write_wait, wait);
663
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))
668                 mask |= EPOLLHUP;
669         if (tty_hung_up_p(filp))
670                 mask |= EPOLLHUP;
671         if (!tty_is_writelocked(tty) &&
672                         !list_empty(&n_hdlc->tx_free_buf_list.list))
673                 mask |= EPOLLOUT | EPOLLWRNORM; /* writable */
674
675         return mask;
676 }       /* end of n_hdlc_tty_poll() */
677
678 static void n_hdlc_alloc_buf(struct n_hdlc_buf_list *list, unsigned int count,
679                 const char *name)
680 {
681         struct n_hdlc_buf *buf;
682         unsigned int i;
683
684         for (i = 0; i < count; i++) {
685                 buf = kmalloc(struct_size(buf, buf, maxframe), GFP_KERNEL);
686                 if (!buf) {
687                         pr_debug("%s(), kmalloc() failed for %s buffer %u\n",
688                                         __func__, name, i);
689                         return;
690                 }
691                 n_hdlc_buf_put(list, buf);
692         }
693 }
694
695 /**
696  * n_hdlc_alloc - allocate an n_hdlc instance data structure
697  *
698  * Returns a pointer to newly created structure if success, otherwise %NULL
699  */
700 static struct n_hdlc *n_hdlc_alloc(void)
701 {
702         struct n_hdlc *n_hdlc = kzalloc(sizeof(*n_hdlc), GFP_KERNEL);
703
704         if (!n_hdlc)
705                 return NULL;
706
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);
711
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);
716
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");
719
720         /* Initialize the control block */
721         n_hdlc->magic  = HDLC_MAGIC;
722
723         return n_hdlc;
724
725 }       /* end of n_hdlc_alloc() */
726
727 /**
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
731  */
732 static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list,
733                                                 struct n_hdlc_buf *buf)
734 {
735         unsigned long flags;
736
737         spin_lock_irqsave(&buf_list->spinlock, flags);
738
739         list_add(&buf->list_item, &buf_list->list);
740         buf_list->count++;
741
742         spin_unlock_irqrestore(&buf_list->spinlock, flags);
743 }
744
745 /**
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
749  */
750 static void n_hdlc_buf_put(struct n_hdlc_buf_list *buf_list,
751                            struct n_hdlc_buf *buf)
752 {
753         unsigned long flags;
754
755         spin_lock_irqsave(&buf_list->spinlock, flags);
756
757         list_add_tail(&buf->list_item, &buf_list->list);
758         buf_list->count++;
759
760         spin_unlock_irqrestore(&buf_list->spinlock, flags);
761 }       /* end of n_hdlc_buf_put() */
762
763 /**
764  * n_hdlc_buf_get - remove and return an HDLC buffer from list
765  * @buf_list: pointer to HDLC buffer list
766  *
767  * Remove and return an HDLC buffer from the head of the specified HDLC buffer
768  * list.
769  * Returns a pointer to HDLC buffer if available, otherwise %NULL.
770  */
771 static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *buf_list)
772 {
773         unsigned long flags;
774         struct n_hdlc_buf *buf;
775
776         spin_lock_irqsave(&buf_list->spinlock, flags);
777
778         buf = list_first_entry_or_null(&buf_list->list,
779                                                 struct n_hdlc_buf, list_item);
780         if (buf) {
781                 list_del(&buf->list_item);
782                 buf_list->count--;
783         }
784
785         spin_unlock_irqrestore(&buf_list->spinlock, flags);
786         return buf;
787 }       /* end of n_hdlc_buf_get() */
788
789 static struct tty_ldisc_ops n_hdlc_ldisc = {
790         .owner          = THIS_MODULE,
791         .name           = "hdlc",
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,
801 };
802
803 static int __init n_hdlc_init(void)
804 {
805         int status;
806
807         /* range check maxframe arg */
808         maxframe = clamp(maxframe, 4096, MAX_HDLC_FRAME_SIZE);
809
810         status = tty_register_ldisc(N_HDLC, &n_hdlc_ldisc);
811         if (!status)
812                 pr_info("N_HDLC line discipline registered with maxframe=%d\n",
813                                 maxframe);
814         else
815                 pr_err("N_HDLC: error registering line discipline: %d\n",
816                                 status);
817
818         return status;
819
820 }       /* end of init_module() */
821
822 static void __exit n_hdlc_exit(void)
823 {
824         /* Release tty registration of line discipline */
825         int status = tty_unregister_ldisc(N_HDLC);
826
827         if (status)
828                 pr_err("N_HDLC: can't unregister line discipline (err = %d)\n",
829                                 status);
830         else
831                 pr_info("N_HDLC: line discipline unregistered\n");
832 }
833
834 module_init(n_hdlc_init);
835 module_exit(n_hdlc_exit);
836
837 MODULE_LICENSE("GPL");
838 MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com");
839 module_param(maxframe, int, 0);
840 MODULE_ALIAS_LDISC(N_HDLC);