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 struct work_struct write_work; 144 struct tty_struct *tty_for_write_work; 145}; 146 147/* 148 * HDLC buffer list manipulation functions 149 */ 150static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list, 151 struct n_hdlc_buf *buf); 152static void n_hdlc_buf_put(struct n_hdlc_buf_list *list, 153 struct n_hdlc_buf *buf); 154static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *list); 155 156/* Local functions */ 157 158static struct n_hdlc *n_hdlc_alloc(void); 159static void n_hdlc_tty_write_work(struct work_struct *work); 160 161/* max frame size for memory allocations */ 162static int maxframe = 4096; 163 164static void flush_rx_queue(struct tty_struct *tty) 165{ 166 struct n_hdlc *n_hdlc = tty->disc_data; 167 struct n_hdlc_buf *buf; 168 169 while ((buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list))) 170 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, buf); 171} 172 173static void flush_tx_queue(struct tty_struct *tty) 174{ 175 struct n_hdlc *n_hdlc = tty->disc_data; 176 struct n_hdlc_buf *buf; 177 178 while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list))) 179 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf); 180} 181 182static void n_hdlc_free_buf_list(struct n_hdlc_buf_list *list) 183{ 184 struct n_hdlc_buf *buf; 185 186 do { 187 buf = n_hdlc_buf_get(list); 188 kfree(buf); 189 } while (buf); 190} 191 192/** 193 * n_hdlc_tty_close - line discipline close 194 * @tty: pointer to tty info structure 195 * 196 * Called when the line discipline is changed to something 197 * else, the tty is closed, or the tty detects a hangup. 198 */ 199static void n_hdlc_tty_close(struct tty_struct *tty) 200{ 201 struct n_hdlc *n_hdlc = tty->disc_data; 202 203 if (n_hdlc->magic != HDLC_MAGIC) { 204 pr_warn("n_hdlc: trying to close unopened tty!\n"); 205 return; 206 } 207#if defined(TTY_NO_WRITE_SPLIT) 208 clear_bit(TTY_NO_WRITE_SPLIT, &tty->flags); 209#endif 210 tty->disc_data = NULL; 211 212 /* Ensure that the n_hdlcd process is not hanging on select()/poll() */ 213 wake_up_interruptible(&tty->read_wait); 214 wake_up_interruptible(&tty->write_wait); 215 216 cancel_work_sync(&n_hdlc->write_work); 217 218 n_hdlc_free_buf_list(&n_hdlc->rx_free_buf_list); 219 n_hdlc_free_buf_list(&n_hdlc->tx_free_buf_list); 220 n_hdlc_free_buf_list(&n_hdlc->rx_buf_list); 221 n_hdlc_free_buf_list(&n_hdlc->tx_buf_list); 222 kfree(n_hdlc); 223} /* end of n_hdlc_tty_close() */ 224 225/** 226 * n_hdlc_tty_open - called when line discipline changed to n_hdlc 227 * @tty: pointer to tty info structure 228 * 229 * Returns 0 if success, otherwise error code 230 */ 231static int n_hdlc_tty_open(struct tty_struct *tty) 232{ 233 struct n_hdlc *n_hdlc = tty->disc_data; 234 235 pr_debug("%s() called (device=%s)\n", __func__, tty->name); 236 237 /* There should not be an existing table for this slot. */ 238 if (n_hdlc) { 239 pr_err("%s: tty already associated!\n", __func__); 240 return -EEXIST; 241 } 242 243 n_hdlc = n_hdlc_alloc(); 244 if (!n_hdlc) { 245 pr_err("%s: n_hdlc_alloc failed\n", __func__); 246 return -ENFILE; 247 } 248 249 INIT_WORK(&n_hdlc->write_work, n_hdlc_tty_write_work); 250 n_hdlc->tty_for_write_work = tty; 251 tty->disc_data = n_hdlc; 252 tty->receive_room = 65536; 253 254 /* change tty_io write() to not split large writes into 8K chunks */ 255 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags); 256 257 /* flush receive data from driver */ 258 tty_driver_flush_buffer(tty); 259 260 return 0; 261 262} /* end of n_tty_hdlc_open() */ 263 264/** 265 * n_hdlc_send_frames - send frames on pending send buffer list 266 * @n_hdlc: pointer to ldisc instance data 267 * @tty: pointer to tty instance data 268 * 269 * Send frames on pending send buffer list until the driver does not accept a 270 * frame (busy) this function is called after adding a frame to the send buffer 271 * list and by the tty wakeup callback. 272 */ 273static void n_hdlc_send_frames(struct n_hdlc *n_hdlc, struct tty_struct *tty) 274{ 275 register int actual; 276 unsigned long flags; 277 struct n_hdlc_buf *tbuf; 278 279check_again: 280 281 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags); 282 if (n_hdlc->tbusy) { 283 n_hdlc->woke_up = true; 284 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 285 return; 286 } 287 n_hdlc->tbusy = true; 288 n_hdlc->woke_up = false; 289 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 290 291 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 292 while (tbuf) { 293 pr_debug("sending frame %p, count=%d\n", tbuf, tbuf->count); 294 295 /* Send the next block of data to device */ 296 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 297 actual = tty->ops->write(tty, tbuf->buf, tbuf->count); 298 299 /* rollback was possible and has been done */ 300 if (actual == -ERESTARTSYS) { 301 n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf); 302 break; 303 } 304 /* if transmit error, throw frame away by */ 305 /* pretending it was accepted by driver */ 306 if (actual < 0) 307 actual = tbuf->count; 308 309 if (actual == tbuf->count) { 310 pr_debug("frame %p completed\n", tbuf); 311 312 /* free current transmit buffer */ 313 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, tbuf); 314 315 /* wait up sleeping writers */ 316 wake_up_interruptible(&tty->write_wait); 317 318 /* get next pending transmit buffer */ 319 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 320 } else { 321 pr_debug("frame %p pending\n", tbuf); 322 323 /* 324 * the buffer was not accepted by driver, 325 * return it back into tx queue 326 */ 327 n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf); 328 break; 329 } 330 } 331 332 if (!tbuf) 333 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 334 335 /* Clear the re-entry flag */ 336 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags); 337 n_hdlc->tbusy = false; 338 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 339 340 if (n_hdlc->woke_up) 341 goto check_again; 342} /* end of n_hdlc_send_frames() */ 343 344/** 345 * n_hdlc_tty_write_work - Asynchronous callback for transmit wakeup 346 * @work: pointer to work_struct 347 * 348 * Called when low level device driver can accept more send data. 349 */ 350static void n_hdlc_tty_write_work(struct work_struct *work) 351{ 352 struct n_hdlc *n_hdlc = container_of(work, struct n_hdlc, write_work); 353 struct tty_struct *tty = n_hdlc->tty_for_write_work; 354 355 n_hdlc_send_frames(n_hdlc, tty); 356} /* end of n_hdlc_tty_write_work() */ 357 358/** 359 * n_hdlc_tty_wakeup - Callback for transmit wakeup 360 * @tty: pointer to associated tty instance data 361 * 362 * Called when low level device driver can accept more send data. 363 */ 364static void n_hdlc_tty_wakeup(struct tty_struct *tty) 365{ 366 struct n_hdlc *n_hdlc = tty->disc_data; 367 368 schedule_work(&n_hdlc->write_work); 369} /* end of n_hdlc_tty_wakeup() */ 370 371/** 372 * n_hdlc_tty_receive - Called by tty driver when receive data is available 373 * @tty: pointer to tty instance data 374 * @data: pointer to received data 375 * @flags: pointer to flags for data 376 * @count: count of received data in bytes 377 * 378 * Called by tty low level driver when receive data is available. Data is 379 * interpreted as one HDLC frame. 380 */ 381static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data, 382 char *flags, int count) 383{ 384 register struct n_hdlc *n_hdlc = tty->disc_data; 385 register struct n_hdlc_buf *buf; 386 387 pr_debug("%s() called count=%d\n", __func__, count); 388 389 /* verify line is using HDLC discipline */ 390 if (n_hdlc->magic != HDLC_MAGIC) { 391 pr_err("line not using HDLC discipline\n"); 392 return; 393 } 394 395 if (count > maxframe) { 396 pr_debug("rx count>maxframesize, data discarded\n"); 397 return; 398 } 399 400 /* get a free HDLC buffer */ 401 buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list); 402 if (!buf) { 403 /* 404 * no buffers in free list, attempt to allocate another rx 405 * buffer unless the maximum count has been reached 406 */ 407 if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT) 408 buf = kmalloc(struct_size(buf, buf, maxframe), 409 GFP_ATOMIC); 410 } 411 412 if (!buf) { 413 pr_debug("no more rx buffers, data discarded\n"); 414 return; 415 } 416 417 /* copy received data to HDLC buffer */ 418 memcpy(buf->buf, data, count); 419 buf->count = count; 420 421 /* add HDLC buffer to list of received frames */ 422 n_hdlc_buf_put(&n_hdlc->rx_buf_list, buf); 423 424 /* wake up any blocked reads and perform async signalling */ 425 wake_up_interruptible(&tty->read_wait); 426 if (tty->fasync != NULL) 427 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 428 429} /* end of n_hdlc_tty_receive() */ 430 431/** 432 * n_hdlc_tty_read - Called to retrieve one frame of data (if available) 433 * @tty: pointer to tty instance data 434 * @file: pointer to open file object 435 * @buf: pointer to returned data buffer 436 * @nr: size of returned data buffer 437 * 438 * Returns the number of bytes returned or error code. 439 */ 440static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file, 441 __u8 *kbuf, size_t nr, 442 void **cookie, unsigned long offset) 443{ 444 struct n_hdlc *n_hdlc = tty->disc_data; 445 int ret = 0; 446 struct n_hdlc_buf *rbuf; 447 DECLARE_WAITQUEUE(wait, current); 448 449 /* Is this a repeated call for an rbuf we already found earlier? */ 450 rbuf = *cookie; 451 if (rbuf) 452 goto have_rbuf; 453 454 add_wait_queue(&tty->read_wait, &wait); 455 456 for (;;) { 457 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { 458 ret = -EIO; 459 break; 460 } 461 if (tty_hung_up_p(file)) 462 break; 463 464 set_current_state(TASK_INTERRUPTIBLE); 465 466 rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list); 467 if (rbuf) 468 break; 469 470 /* no data */ 471 if (tty_io_nonblock(tty, file)) { 472 ret = -EAGAIN; 473 break; 474 } 475 476 schedule(); 477 478 if (signal_pending(current)) { 479 ret = -EINTR; 480 break; 481 } 482 } 483 484 remove_wait_queue(&tty->read_wait, &wait); 485 __set_current_state(TASK_RUNNING); 486 487 if (!rbuf) 488 return ret; 489 *cookie = rbuf; 490 491have_rbuf: 492 /* Have we used it up entirely? */ 493 if (offset >= rbuf->count) 494 goto done_with_rbuf; 495 496 /* More data to go, but can't copy any more? EOVERFLOW */ 497 ret = -EOVERFLOW; 498 if (!nr) 499 goto done_with_rbuf; 500 501 /* Copy as much data as possible */ 502 ret = rbuf->count - offset; 503 if (ret > nr) 504 ret = nr; 505 memcpy(kbuf, rbuf->buf+offset, ret); 506 offset += ret; 507 508 /* If we still have data left, we leave the rbuf in the cookie */ 509 if (offset < rbuf->count) 510 return ret; 511 512done_with_rbuf: 513 *cookie = NULL; 514 515 if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT) 516 kfree(rbuf); 517 else 518 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, rbuf); 519 520 return ret; 521 522} /* end of n_hdlc_tty_read() */ 523 524/** 525 * n_hdlc_tty_write - write a single frame of data to device 526 * @tty: pointer to associated tty device instance data 527 * @file: pointer to file object data 528 * @data: pointer to transmit data (one frame) 529 * @count: size of transmit frame in bytes 530 * 531 * Returns the number of bytes written (or error code). 532 */ 533static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file, 534 const unsigned char *data, size_t count) 535{ 536 struct n_hdlc *n_hdlc = tty->disc_data; 537 int error = 0; 538 DECLARE_WAITQUEUE(wait, current); 539 struct n_hdlc_buf *tbuf; 540 541 pr_debug("%s() called count=%zd\n", __func__, count); 542 543 if (n_hdlc->magic != HDLC_MAGIC) 544 return -EIO; 545 546 /* verify frame size */ 547 if (count > maxframe) { 548 pr_debug("%s: truncating user packet from %zu to %d\n", 549 __func__, count, maxframe); 550 count = maxframe; 551 } 552 553 add_wait_queue(&tty->write_wait, &wait); 554 555 for (;;) { 556 set_current_state(TASK_INTERRUPTIBLE); 557 558 tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list); 559 if (tbuf) 560 break; 561 562 if (tty_io_nonblock(tty, file)) { 563 error = -EAGAIN; 564 break; 565 } 566 schedule(); 567 568 if (signal_pending(current)) { 569 error = -EINTR; 570 break; 571 } 572 } 573 574 __set_current_state(TASK_RUNNING); 575 remove_wait_queue(&tty->write_wait, &wait); 576 577 if (!error) { 578 /* Retrieve the user's buffer */ 579 memcpy(tbuf->buf, data, count); 580 581 /* Send the data */ 582 tbuf->count = error = count; 583 n_hdlc_buf_put(&n_hdlc->tx_buf_list, tbuf); 584 n_hdlc_send_frames(n_hdlc, tty); 585 } 586 587 return error; 588 589} /* end of n_hdlc_tty_write() */ 590 591/** 592 * n_hdlc_tty_ioctl - process IOCTL system call for the tty device. 593 * @tty: pointer to tty instance data 594 * @file: pointer to open file object for device 595 * @cmd: IOCTL command code 596 * @arg: argument for IOCTL call (cmd dependent) 597 * 598 * Returns command dependent result. 599 */ 600static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file, 601 unsigned int cmd, unsigned long arg) 602{ 603 struct n_hdlc *n_hdlc = tty->disc_data; 604 int error = 0; 605 int count; 606 unsigned long flags; 607 struct n_hdlc_buf *buf = NULL; 608 609 pr_debug("%s() called %d\n", __func__, cmd); 610 611 /* Verify the status of the device */ 612 if (n_hdlc->magic != HDLC_MAGIC) 613 return -EBADF; 614 615 switch (cmd) { 616 case FIONREAD: 617 /* report count of read data available */ 618 /* in next available frame (if any) */ 619 spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock, flags); 620 buf = list_first_entry_or_null(&n_hdlc->rx_buf_list.list, 621 struct n_hdlc_buf, list_item); 622 if (buf) 623 count = buf->count; 624 else 625 count = 0; 626 spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock, flags); 627 error = put_user(count, (int __user *)arg); 628 break; 629 630 case TIOCOUTQ: 631 /* get the pending tx byte count in the driver */ 632 count = tty_chars_in_buffer(tty); 633 /* add size of next output frame in queue */ 634 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags); 635 buf = list_first_entry_or_null(&n_hdlc->tx_buf_list.list, 636 struct n_hdlc_buf, list_item); 637 if (buf) 638 count += buf->count; 639 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 640 error = put_user(count, (int __user *)arg); 641 break; 642 643 case TCFLSH: 644 switch (arg) { 645 case TCIOFLUSH: 646 case TCOFLUSH: 647 flush_tx_queue(tty); 648 } 649 fallthrough; /* to default */ 650 651 default: 652 error = n_tty_ioctl_helper(tty, file, cmd, arg); 653 break; 654 } 655 return error; 656 657} /* end of n_hdlc_tty_ioctl() */ 658 659/** 660 * n_hdlc_tty_poll - TTY callback for poll system call 661 * @tty: pointer to tty instance data 662 * @filp: pointer to open file object for device 663 * @wait: wait queue for operations 664 * 665 * Determine which operations (read/write) will not block and return info 666 * to caller. 667 * Returns a bit mask containing info on which ops will not block. 668 */ 669static __poll_t n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp, 670 poll_table *wait) 671{ 672 struct n_hdlc *n_hdlc = tty->disc_data; 673 __poll_t mask = 0; 674 675 if (n_hdlc->magic != HDLC_MAGIC) 676 return 0; 677 678 /* 679 * queue the current process into any wait queue that may awaken in the 680 * future (read and write) 681 */ 682 poll_wait(filp, &tty->read_wait, wait); 683 poll_wait(filp, &tty->write_wait, wait); 684 685 /* set bits for operations that won't block */ 686 if (!list_empty(&n_hdlc->rx_buf_list.list)) 687 mask |= EPOLLIN | EPOLLRDNORM; /* readable */ 688 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) 689 mask |= EPOLLHUP; 690 if (tty_hung_up_p(filp)) 691 mask |= EPOLLHUP; 692 if (!tty_is_writelocked(tty) && 693 !list_empty(&n_hdlc->tx_free_buf_list.list)) 694 mask |= EPOLLOUT | EPOLLWRNORM; /* writable */ 695 696 return mask; 697} /* end of n_hdlc_tty_poll() */ 698 699static void n_hdlc_alloc_buf(struct n_hdlc_buf_list *list, unsigned int count, 700 const char *name) 701{ 702 struct n_hdlc_buf *buf; 703 unsigned int i; 704 705 for (i = 0; i < count; i++) { 706 buf = kmalloc(struct_size(buf, buf, maxframe), GFP_KERNEL); 707 if (!buf) { 708 pr_debug("%s(), kmalloc() failed for %s buffer %u\n", 709 __func__, name, i); 710 return; 711 } 712 n_hdlc_buf_put(list, buf); 713 } 714} 715 716/** 717 * n_hdlc_alloc - allocate an n_hdlc instance data structure 718 * 719 * Returns a pointer to newly created structure if success, otherwise %NULL 720 */ 721static struct n_hdlc *n_hdlc_alloc(void) 722{ 723 struct n_hdlc *n_hdlc = kzalloc(sizeof(*n_hdlc), GFP_KERNEL); 724 725 if (!n_hdlc) 726 return NULL; 727 728 spin_lock_init(&n_hdlc->rx_free_buf_list.spinlock); 729 spin_lock_init(&n_hdlc->tx_free_buf_list.spinlock); 730 spin_lock_init(&n_hdlc->rx_buf_list.spinlock); 731 spin_lock_init(&n_hdlc->tx_buf_list.spinlock); 732 733 INIT_LIST_HEAD(&n_hdlc->rx_free_buf_list.list); 734 INIT_LIST_HEAD(&n_hdlc->tx_free_buf_list.list); 735 INIT_LIST_HEAD(&n_hdlc->rx_buf_list.list); 736 INIT_LIST_HEAD(&n_hdlc->tx_buf_list.list); 737 738 n_hdlc_alloc_buf(&n_hdlc->rx_free_buf_list, DEFAULT_RX_BUF_COUNT, "rx"); 739 n_hdlc_alloc_buf(&n_hdlc->tx_free_buf_list, DEFAULT_TX_BUF_COUNT, "tx"); 740 741 /* Initialize the control block */ 742 n_hdlc->magic = HDLC_MAGIC; 743 744 return n_hdlc; 745 746} /* end of n_hdlc_alloc() */ 747 748/** 749 * n_hdlc_buf_return - put the HDLC buffer after the head of the specified list 750 * @buf_list: pointer to the buffer list 751 * @buf: pointer to the buffer 752 */ 753static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list, 754 struct n_hdlc_buf *buf) 755{ 756 unsigned long flags; 757 758 spin_lock_irqsave(&buf_list->spinlock, flags); 759 760 list_add(&buf->list_item, &buf_list->list); 761 buf_list->count++; 762 763 spin_unlock_irqrestore(&buf_list->spinlock, flags); 764} 765 766/** 767 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list 768 * @buf_list: pointer to buffer list 769 * @buf: pointer to buffer 770 */ 771static void n_hdlc_buf_put(struct n_hdlc_buf_list *buf_list, 772 struct n_hdlc_buf *buf) 773{ 774 unsigned long flags; 775 776 spin_lock_irqsave(&buf_list->spinlock, flags); 777 778 list_add_tail(&buf->list_item, &buf_list->list); 779 buf_list->count++; 780 781 spin_unlock_irqrestore(&buf_list->spinlock, flags); 782} /* end of n_hdlc_buf_put() */ 783 784/** 785 * n_hdlc_buf_get - remove and return an HDLC buffer from list 786 * @buf_list: pointer to HDLC buffer list 787 * 788 * Remove and return an HDLC buffer from the head of the specified HDLC buffer 789 * list. 790 * Returns a pointer to HDLC buffer if available, otherwise %NULL. 791 */ 792static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *buf_list) 793{ 794 unsigned long flags; 795 struct n_hdlc_buf *buf; 796 797 spin_lock_irqsave(&buf_list->spinlock, flags); 798 799 buf = list_first_entry_or_null(&buf_list->list, 800 struct n_hdlc_buf, list_item); 801 if (buf) { 802 list_del(&buf->list_item); 803 buf_list->count--; 804 } 805 806 spin_unlock_irqrestore(&buf_list->spinlock, flags); 807 return buf; 808} /* end of n_hdlc_buf_get() */ 809 810static struct tty_ldisc_ops n_hdlc_ldisc = { 811 .owner = THIS_MODULE, 812 .magic = TTY_LDISC_MAGIC, 813 .name = "hdlc", 814 .open = n_hdlc_tty_open, 815 .close = n_hdlc_tty_close, 816 .read = n_hdlc_tty_read, 817 .write = n_hdlc_tty_write, 818 .ioctl = n_hdlc_tty_ioctl, 819 .poll = n_hdlc_tty_poll, 820 .receive_buf = n_hdlc_tty_receive, 821 .write_wakeup = n_hdlc_tty_wakeup, 822 .flush_buffer = flush_rx_queue, 823}; 824 825static int __init n_hdlc_init(void) 826{ 827 int status; 828 829 /* range check maxframe arg */ 830 maxframe = clamp(maxframe, 4096, MAX_HDLC_FRAME_SIZE); 831 832 status = tty_register_ldisc(N_HDLC, &n_hdlc_ldisc); 833 if (!status) 834 pr_info("N_HDLC line discipline registered with maxframe=%d\n", 835 maxframe); 836 else 837 pr_err("N_HDLC: error registering line discipline: %d\n", 838 status); 839 840 return status; 841 842} /* end of init_module() */ 843 844static void __exit n_hdlc_exit(void) 845{ 846 /* Release tty registration of line discipline */ 847 int status = tty_unregister_ldisc(N_HDLC); 848 849 if (status) 850 pr_err("N_HDLC: can't unregister line discipline (err = %d)\n", 851 status); 852 else 853 pr_info("N_HDLC: line discipline unregistered\n"); 854} 855 856module_init(n_hdlc_init); 857module_exit(n_hdlc_exit); 858 859MODULE_LICENSE("GPL"); 860MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com"); 861module_param(maxframe, int, 0); 862MODULE_ALIAS_LDISC(N_HDLC); 863