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 #include <linux/module.h> 80 #include <linux/init.h> 81 #include <linux/kernel.h> 82 #include <linux/sched.h> 83 #include <linux/types.h> 84 #include <linux/fcntl.h> 85 #include <linux/interrupt.h> 86 #include <linux/ptrace.h> 87 88 #include <linux/poll.h> 89 #include <linux/in.h> 90 #include <linux/ioctl.h> 91 #include <linux/slab.h> 92 #include <linux/tty.h> 93 #include <linux/errno.h> 94 #include <linux/string.h> /* used in new tty drivers */ 95 #include <linux/signal.h> /* used in new tty drivers */ 96 #include <linux/if.h> 97 #include <linux/bitops.h> 98 99 #include <linux/uaccess.h> 100 #include "tty.h" 101 102 /* 103 * Buffers for individual HDLC frames 104 */ 105 #define MAX_HDLC_FRAME_SIZE 65535 106 #define DEFAULT_RX_BUF_COUNT 10 107 #define MAX_RX_BUF_COUNT 60 108 #define DEFAULT_TX_BUF_COUNT 3 109 110 struct n_hdlc_buf { 111 struct list_head list_item; 112 size_t count; 113 u8 buf[]; 114 }; 115 116 struct n_hdlc_buf_list { 117 struct list_head list; 118 int count; 119 spinlock_t spinlock; 120 }; 121 122 /** 123 * struct n_hdlc - per device instance data structure 124 * @tbusy: reentrancy flag for tx wakeup code 125 * @woke_up: tx wakeup needs to be run again as it was called while @tbusy 126 * @tx_buf_list: list of pending transmit frame buffers 127 * @rx_buf_list: list of received frame buffers 128 * @tx_free_buf_list: list unused transmit frame buffers 129 * @rx_free_buf_list: list unused received frame buffers 130 * @write_work: work struct for deferred frame transmission 131 * @tty_for_write_work: pointer to tty instance used by the @write_work 132 */ 133 struct n_hdlc { 134 bool tbusy; 135 bool woke_up; 136 struct n_hdlc_buf_list tx_buf_list; 137 struct n_hdlc_buf_list rx_buf_list; 138 struct n_hdlc_buf_list tx_free_buf_list; 139 struct n_hdlc_buf_list rx_free_buf_list; 140 struct work_struct write_work; 141 struct tty_struct *tty_for_write_work; 142 }; 143 144 /* 145 * HDLC buffer list manipulation functions 146 */ 147 static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list, 148 struct n_hdlc_buf *buf); 149 static void n_hdlc_buf_put(struct n_hdlc_buf_list *list, 150 struct n_hdlc_buf *buf); 151 static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *list); 152 153 /* Local functions */ 154 155 static struct n_hdlc *n_hdlc_alloc(void); 156 static void n_hdlc_tty_write_work(struct work_struct *work); 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 defined(TTY_NO_WRITE_SPLIT) 201 clear_bit(TTY_NO_WRITE_SPLIT, &tty->flags); 202 #endif 203 tty->disc_data = NULL; 204 205 /* Ensure that the n_hdlcd process is not hanging on select()/poll() */ 206 wake_up_interruptible(&tty->read_wait); 207 wake_up_interruptible(&tty->write_wait); 208 209 cancel_work_sync(&n_hdlc->write_work); 210 211 n_hdlc_free_buf_list(&n_hdlc->rx_free_buf_list); 212 n_hdlc_free_buf_list(&n_hdlc->tx_free_buf_list); 213 n_hdlc_free_buf_list(&n_hdlc->rx_buf_list); 214 n_hdlc_free_buf_list(&n_hdlc->tx_buf_list); 215 kfree(n_hdlc); 216 } /* end of n_hdlc_tty_close() */ 217 218 /** 219 * n_hdlc_tty_open - called when line discipline changed to n_hdlc 220 * @tty: pointer to tty info structure 221 * 222 * Returns 0 if success, otherwise error code 223 */ 224 static int n_hdlc_tty_open(struct tty_struct *tty) 225 { 226 struct n_hdlc *n_hdlc = tty->disc_data; 227 228 pr_debug("%s() called (device=%s)\n", __func__, tty->name); 229 230 /* There should not be an existing table for this slot. */ 231 if (n_hdlc) { 232 pr_err("%s: tty already associated!\n", __func__); 233 return -EEXIST; 234 } 235 236 n_hdlc = n_hdlc_alloc(); 237 if (!n_hdlc) { 238 pr_err("%s: n_hdlc_alloc failed\n", __func__); 239 return -ENFILE; 240 } 241 242 INIT_WORK(&n_hdlc->write_work, n_hdlc_tty_write_work); 243 n_hdlc->tty_for_write_work = tty; 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 struct n_hdlc_buf *tbuf; 269 ssize_t actual; 270 271 check_again: 272 scoped_guard(spinlock_irqsave, &n_hdlc->tx_buf_list.spinlock) { 273 if (n_hdlc->tbusy) { 274 n_hdlc->woke_up = true; 275 return; 276 } 277 n_hdlc->tbusy = true; 278 n_hdlc->woke_up = false; 279 } 280 281 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 282 while (tbuf) { 283 pr_debug("sending frame %p, count=%zu\n", tbuf, tbuf->count); 284 285 /* Send the next block of data to device */ 286 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 287 actual = tty->ops->write(tty, tbuf->buf, tbuf->count); 288 289 /* rollback was possible and has been done */ 290 if (actual == -ERESTARTSYS) { 291 n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf); 292 break; 293 } 294 /* if transmit error, throw frame away by */ 295 /* pretending it was accepted by driver */ 296 if (actual < 0) 297 actual = tbuf->count; 298 299 if (actual == tbuf->count) { 300 pr_debug("frame %p completed\n", tbuf); 301 302 /* free current transmit buffer */ 303 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, tbuf); 304 305 /* wait up sleeping writers */ 306 wake_up_interruptible(&tty->write_wait); 307 308 /* get next pending transmit buffer */ 309 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 310 } else { 311 pr_debug("frame %p pending\n", tbuf); 312 313 /* 314 * the buffer was not accepted by driver, 315 * return it back into tx queue 316 */ 317 n_hdlc_buf_return(&n_hdlc->tx_buf_list, tbuf); 318 break; 319 } 320 } 321 322 if (!tbuf) 323 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 324 325 /* Clear the re-entry flag */ 326 scoped_guard(spinlock_irqsave, &n_hdlc->tx_buf_list.spinlock) 327 n_hdlc->tbusy = false; 328 329 if (n_hdlc->woke_up) 330 goto check_again; 331 } /* end of n_hdlc_send_frames() */ 332 333 /** 334 * n_hdlc_tty_write_work - Asynchronous callback for transmit wakeup 335 * @work: pointer to work_struct 336 * 337 * Called when low level device driver can accept more send data. 338 */ 339 static void n_hdlc_tty_write_work(struct work_struct *work) 340 { 341 struct n_hdlc *n_hdlc = container_of(work, struct n_hdlc, write_work); 342 struct tty_struct *tty = n_hdlc->tty_for_write_work; 343 344 n_hdlc_send_frames(n_hdlc, tty); 345 } /* end of n_hdlc_tty_write_work() */ 346 347 /** 348 * n_hdlc_tty_wakeup - Callback for transmit wakeup 349 * @tty: pointer to associated tty instance data 350 * 351 * Called when low level device driver can accept more send data. 352 */ 353 static void n_hdlc_tty_wakeup(struct tty_struct *tty) 354 { 355 struct n_hdlc *n_hdlc = tty->disc_data; 356 357 schedule_work(&n_hdlc->write_work); 358 } /* end of n_hdlc_tty_wakeup() */ 359 360 /** 361 * n_hdlc_tty_receive - Called by tty driver when receive data is available 362 * @tty: pointer to tty instance data 363 * @data: pointer to received data 364 * @flags: pointer to flags for data 365 * @count: count of received data in bytes 366 * 367 * Called by tty low level driver when receive data is available. Data is 368 * interpreted as one HDLC frame. 369 */ 370 static void n_hdlc_tty_receive(struct tty_struct *tty, const u8 *data, 371 const u8 *flags, size_t count) 372 { 373 register struct n_hdlc *n_hdlc = tty->disc_data; 374 register struct n_hdlc_buf *buf; 375 376 pr_debug("%s() called count=%zu\n", __func__, count); 377 378 if (count > maxframe) { 379 pr_debug("rx count>maxframesize, data discarded\n"); 380 return; 381 } 382 383 /* get a free HDLC buffer */ 384 buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list); 385 if (!buf) { 386 /* 387 * no buffers in free list, attempt to allocate another rx 388 * buffer unless the maximum count has been reached 389 */ 390 if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT) 391 buf = kmalloc(struct_size(buf, buf, maxframe), 392 GFP_ATOMIC); 393 } 394 395 if (!buf) { 396 pr_debug("no more rx buffers, data discarded\n"); 397 return; 398 } 399 400 /* copy received data to HDLC buffer */ 401 memcpy(buf->buf, data, count); 402 buf->count = count; 403 404 /* add HDLC buffer to list of received frames */ 405 n_hdlc_buf_put(&n_hdlc->rx_buf_list, buf); 406 407 /* wake up any blocked reads and perform async signalling */ 408 wake_up_interruptible(&tty->read_wait); 409 if (tty->fasync != NULL) 410 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 411 412 } /* end of n_hdlc_tty_receive() */ 413 414 /** 415 * n_hdlc_tty_read - Called to retrieve one frame of data (if available) 416 * @tty: pointer to tty instance data 417 * @file: pointer to open file object 418 * @kbuf: pointer to returned data buffer 419 * @nr: size of returned data buffer 420 * @cookie: stored rbuf from previous run 421 * @offset: offset into the data buffer 422 * 423 * Returns the number of bytes returned or error code. 424 */ 425 static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file, 426 u8 *kbuf, size_t nr, void **cookie, 427 unsigned long offset) 428 { 429 struct n_hdlc *n_hdlc = tty->disc_data; 430 int ret = 0; 431 struct n_hdlc_buf *rbuf; 432 DECLARE_WAITQUEUE(wait, current); 433 434 /* Is this a repeated call for an rbuf we already found earlier? */ 435 rbuf = *cookie; 436 if (rbuf) 437 goto have_rbuf; 438 439 add_wait_queue(&tty->read_wait, &wait); 440 441 for (;;) { 442 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { 443 ret = -EIO; 444 break; 445 } 446 if (tty_hung_up_p(file)) 447 break; 448 449 set_current_state(TASK_INTERRUPTIBLE); 450 451 rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list); 452 if (rbuf) 453 break; 454 455 /* no data */ 456 if (tty_io_nonblock(tty, file)) { 457 ret = -EAGAIN; 458 break; 459 } 460 461 schedule(); 462 463 if (signal_pending(current)) { 464 ret = -EINTR; 465 break; 466 } 467 } 468 469 remove_wait_queue(&tty->read_wait, &wait); 470 __set_current_state(TASK_RUNNING); 471 472 if (!rbuf) 473 return ret; 474 *cookie = rbuf; 475 476 have_rbuf: 477 /* Have we used it up entirely? */ 478 if (offset >= rbuf->count) 479 goto done_with_rbuf; 480 481 /* More data to go, but can't copy any more? EOVERFLOW */ 482 ret = -EOVERFLOW; 483 if (!nr) 484 goto done_with_rbuf; 485 486 /* Copy as much data as possible */ 487 ret = rbuf->count - offset; 488 if (ret > nr) 489 ret = nr; 490 memcpy(kbuf, rbuf->buf+offset, ret); 491 offset += ret; 492 493 /* If we still have data left, we leave the rbuf in the cookie */ 494 if (offset < rbuf->count) 495 return ret; 496 497 done_with_rbuf: 498 *cookie = NULL; 499 500 if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT) 501 kfree(rbuf); 502 else 503 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, rbuf); 504 505 return ret; 506 507 } /* end of n_hdlc_tty_read() */ 508 509 /** 510 * n_hdlc_tty_write - write a single frame of data to device 511 * @tty: pointer to associated tty device instance data 512 * @file: pointer to file object data 513 * @data: pointer to transmit data (one frame) 514 * @count: size of transmit frame in bytes 515 * 516 * Returns the number of bytes written (or error code). 517 */ 518 static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file, 519 const u8 *data, size_t count) 520 { 521 struct n_hdlc *n_hdlc = tty->disc_data; 522 DECLARE_WAITQUEUE(wait, current); 523 struct n_hdlc_buf *tbuf; 524 ssize_t error = 0; 525 526 pr_debug("%s() called count=%zd\n", __func__, count); 527 528 /* verify frame size */ 529 if (count > maxframe) { 530 pr_debug("%s: truncating user packet from %zu to %d\n", 531 __func__, count, maxframe); 532 count = maxframe; 533 } 534 535 add_wait_queue(&tty->write_wait, &wait); 536 537 for (;;) { 538 set_current_state(TASK_INTERRUPTIBLE); 539 540 tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list); 541 if (tbuf) 542 break; 543 544 if (tty_io_nonblock(tty, file)) { 545 error = -EAGAIN; 546 break; 547 } 548 schedule(); 549 550 if (signal_pending(current)) { 551 error = -EINTR; 552 break; 553 } 554 } 555 556 __set_current_state(TASK_RUNNING); 557 remove_wait_queue(&tty->write_wait, &wait); 558 559 if (!error) { 560 /* Retrieve the user's buffer */ 561 memcpy(tbuf->buf, data, count); 562 563 /* Send the data */ 564 tbuf->count = error = count; 565 n_hdlc_buf_put(&n_hdlc->tx_buf_list, tbuf); 566 n_hdlc_send_frames(n_hdlc, tty); 567 } 568 569 return error; 570 571 } /* end of n_hdlc_tty_write() */ 572 573 /** 574 * n_hdlc_tty_ioctl - process IOCTL system call for the tty device. 575 * @tty: pointer to tty instance data 576 * @cmd: IOCTL command code 577 * @arg: argument for IOCTL call (cmd dependent) 578 * 579 * Returns command dependent result. 580 */ 581 static int n_hdlc_tty_ioctl(struct tty_struct *tty, unsigned int cmd, 582 unsigned long arg) 583 { 584 struct n_hdlc *n_hdlc = tty->disc_data; 585 int count; 586 struct n_hdlc_buf *buf = NULL; 587 588 pr_debug("%s() called %d\n", __func__, cmd); 589 590 switch (cmd) { 591 case FIONREAD: 592 /* report count of read data available */ 593 /* in next available frame (if any) */ 594 scoped_guard(spinlock_irqsave, &n_hdlc->rx_buf_list.spinlock) { 595 buf = list_first_entry_or_null(&n_hdlc->rx_buf_list.list, 596 struct n_hdlc_buf, list_item); 597 if (buf) 598 count = buf->count; 599 else 600 count = 0; 601 } 602 return put_user(count, (int __user *)arg); 603 604 case TIOCOUTQ: 605 /* get the pending tx byte count in the driver */ 606 count = tty_chars_in_buffer(tty); 607 /* add size of next output frame in queue */ 608 scoped_guard(spinlock_irqsave, &n_hdlc->tx_buf_list.spinlock) { 609 buf = list_first_entry_or_null(&n_hdlc->tx_buf_list.list, 610 struct n_hdlc_buf, list_item); 611 if (buf) 612 count += buf->count; 613 } 614 return put_user(count, (int __user *)arg); 615 616 case TCFLSH: 617 switch (arg) { 618 case TCIOFLUSH: 619 case TCOFLUSH: 620 flush_tx_queue(tty); 621 } 622 fallthrough; /* to default */ 623 624 default: 625 return n_tty_ioctl_helper(tty, cmd, arg); 626 } 627 } /* end of n_hdlc_tty_ioctl() */ 628 629 /** 630 * n_hdlc_tty_poll - TTY callback for poll system call 631 * @tty: pointer to tty instance data 632 * @filp: pointer to open file object for device 633 * @wait: wait queue for operations 634 * 635 * Determine which operations (read/write) will not block and return info 636 * to caller. 637 * Returns a bit mask containing info on which ops will not block. 638 */ 639 static __poll_t n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp, 640 poll_table *wait) 641 { 642 struct n_hdlc *n_hdlc = tty->disc_data; 643 __poll_t mask = 0; 644 645 /* 646 * queue the current process into any wait queue that may awaken in the 647 * future (read and write) 648 */ 649 poll_wait(filp, &tty->read_wait, wait); 650 poll_wait(filp, &tty->write_wait, wait); 651 652 /* set bits for operations that won't block */ 653 if (!list_empty(&n_hdlc->rx_buf_list.list)) 654 mask |= EPOLLIN | EPOLLRDNORM; /* readable */ 655 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) 656 mask |= EPOLLHUP; 657 if (tty_hung_up_p(filp)) 658 mask |= EPOLLHUP; 659 if (!tty_is_writelocked(tty) && 660 !list_empty(&n_hdlc->tx_free_buf_list.list)) 661 mask |= EPOLLOUT | EPOLLWRNORM; /* writable */ 662 663 return mask; 664 } /* end of n_hdlc_tty_poll() */ 665 666 static void n_hdlc_alloc_buf(struct n_hdlc_buf_list *list, unsigned int count, 667 const char *name) 668 { 669 struct n_hdlc_buf *buf; 670 unsigned int i; 671 672 for (i = 0; i < count; i++) { 673 buf = kmalloc(struct_size(buf, buf, maxframe), GFP_KERNEL); 674 if (!buf) { 675 pr_debug("%s(), kmalloc() failed for %s buffer %u\n", 676 __func__, name, i); 677 return; 678 } 679 n_hdlc_buf_put(list, buf); 680 } 681 } 682 683 /** 684 * n_hdlc_alloc - allocate an n_hdlc instance data structure 685 * 686 * Returns a pointer to newly created structure if success, otherwise %NULL 687 */ 688 static struct n_hdlc *n_hdlc_alloc(void) 689 { 690 struct n_hdlc *n_hdlc = kzalloc(sizeof(*n_hdlc), GFP_KERNEL); 691 692 if (!n_hdlc) 693 return NULL; 694 695 spin_lock_init(&n_hdlc->rx_free_buf_list.spinlock); 696 spin_lock_init(&n_hdlc->tx_free_buf_list.spinlock); 697 spin_lock_init(&n_hdlc->rx_buf_list.spinlock); 698 spin_lock_init(&n_hdlc->tx_buf_list.spinlock); 699 700 INIT_LIST_HEAD(&n_hdlc->rx_free_buf_list.list); 701 INIT_LIST_HEAD(&n_hdlc->tx_free_buf_list.list); 702 INIT_LIST_HEAD(&n_hdlc->rx_buf_list.list); 703 INIT_LIST_HEAD(&n_hdlc->tx_buf_list.list); 704 705 n_hdlc_alloc_buf(&n_hdlc->rx_free_buf_list, DEFAULT_RX_BUF_COUNT, "rx"); 706 n_hdlc_alloc_buf(&n_hdlc->tx_free_buf_list, DEFAULT_TX_BUF_COUNT, "tx"); 707 708 return n_hdlc; 709 710 } /* end of n_hdlc_alloc() */ 711 712 /** 713 * n_hdlc_buf_return - put the HDLC buffer after the head of the specified list 714 * @buf_list: pointer to the buffer list 715 * @buf: pointer to the buffer 716 */ 717 static void n_hdlc_buf_return(struct n_hdlc_buf_list *buf_list, 718 struct n_hdlc_buf *buf) 719 { 720 guard(spinlock_irqsave)(&buf_list->spinlock); 721 722 list_add(&buf->list_item, &buf_list->list); 723 buf_list->count++; 724 } 725 726 /** 727 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list 728 * @buf_list: pointer to buffer list 729 * @buf: pointer to buffer 730 */ 731 static void n_hdlc_buf_put(struct n_hdlc_buf_list *buf_list, 732 struct n_hdlc_buf *buf) 733 { 734 guard(spinlock_irqsave)(&buf_list->spinlock); 735 736 list_add_tail(&buf->list_item, &buf_list->list); 737 buf_list->count++; 738 } /* end of n_hdlc_buf_put() */ 739 740 /** 741 * n_hdlc_buf_get - remove and return an HDLC buffer from list 742 * @buf_list: pointer to HDLC buffer list 743 * 744 * Remove and return an HDLC buffer from the head of the specified HDLC buffer 745 * list. 746 * Returns a pointer to HDLC buffer if available, otherwise %NULL. 747 */ 748 static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *buf_list) 749 { 750 struct n_hdlc_buf *buf; 751 752 guard(spinlock_irqsave)(&buf_list->spinlock); 753 754 buf = list_first_entry_or_null(&buf_list->list, 755 struct n_hdlc_buf, list_item); 756 if (buf) { 757 list_del(&buf->list_item); 758 buf_list->count--; 759 } 760 761 return buf; 762 } /* end of n_hdlc_buf_get() */ 763 764 static struct tty_ldisc_ops n_hdlc_ldisc = { 765 .owner = THIS_MODULE, 766 .num = N_HDLC, 767 .name = "hdlc", 768 .open = n_hdlc_tty_open, 769 .close = n_hdlc_tty_close, 770 .read = n_hdlc_tty_read, 771 .write = n_hdlc_tty_write, 772 .ioctl = n_hdlc_tty_ioctl, 773 .poll = n_hdlc_tty_poll, 774 .receive_buf = n_hdlc_tty_receive, 775 .write_wakeup = n_hdlc_tty_wakeup, 776 .flush_buffer = flush_rx_queue, 777 }; 778 779 static int __init n_hdlc_init(void) 780 { 781 int status; 782 783 /* range check maxframe arg */ 784 maxframe = clamp(maxframe, 4096, MAX_HDLC_FRAME_SIZE); 785 786 status = tty_register_ldisc(&n_hdlc_ldisc); 787 if (!status) 788 pr_info("N_HDLC line discipline registered with maxframe=%d\n", 789 maxframe); 790 else 791 pr_err("N_HDLC: error registering line discipline: %d\n", 792 status); 793 794 return status; 795 796 } /* end of init_module() */ 797 798 static void __exit n_hdlc_exit(void) 799 { 800 tty_unregister_ldisc(&n_hdlc_ldisc); 801 } 802 803 module_init(n_hdlc_init); 804 module_exit(n_hdlc_exit); 805 806 MODULE_DESCRIPTION("HDLC line discipline support"); 807 MODULE_LICENSE("GPL"); 808 MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com"); 809 module_param(maxframe, int, 0); 810 MODULE_ALIAS_LDISC(N_HDLC); 811