linux/drivers/tty/n_hdlc.c
<<
>>
Prefs
   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
 113struct n_hdlc_buf {
 114        struct list_head  list_item;
 115        int               count;
 116        char              buf[];
 117};
 118
 119struct 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 */
 135struct 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 */
 148static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list,
 149                                                struct n_hdlc_buf *buf);
 150static void n_hdlc_buf_put(struct n_hdlc_buf_list *list,
 151                           struct n_hdlc_buf *buf);
 152static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *list);
 153
 154/* Local functions */
 155
 156static struct n_hdlc *n_hdlc_alloc(void);
 157
 158/* max frame size for memory allocations */
 159static int maxframe = 4096;
 160
 161static 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
 170static 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
 179static 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 */
 196static 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 */
 226static 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 */
 266static 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
 272check_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 */
 343static 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 */
 360static 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 */
 419static 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
 470have_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
 491done_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 */
 512static 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 */
 579static 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 */
 648static __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
 678static 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 */
 700static 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 */
 732static 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 */
 750static 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 */
 771static 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
 789static 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
 803static 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
 822static 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
 834module_init(n_hdlc_init);
 835module_exit(n_hdlc_exit);
 836
 837MODULE_LICENSE("GPL");
 838MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com");
 839module_param(maxframe, int, 0);
 840MODULE_ALIAS_LDISC(N_HDLC);
 841