1/* generic HDLC line discipline for Linux 2 * 3 * Written by Paul Fulghum paulkf@microgate.com 4 * for Microgate Corporation 5 * 6 * Microgate and SyncLink are registered trademarks of Microgate Corporation 7 * 8 * Adapted from ppp.c, written by Michael Callahan <callahan@maths.ox.ac.uk>, 9 * Al Longyear <longyear@netcom.com>, 10 * Paul Mackerras <Paul.Mackerras@cs.anu.edu.au> 11 * 12 * Original release 01/11/99 13 * 14 * This code is released under the GNU General Public License (GPL) 15 * 16 * This module implements the tty line discipline N_HDLC for use with 17 * tty device drivers that support bit-synchronous HDLC communications. 18 * 19 * All HDLC data is frame oriented which means: 20 * 21 * 1. tty write calls represent one complete transmit frame of data 22 * The device driver should accept the complete frame or none of 23 * the frame (busy) in the write method. Each write call should have 24 * a byte count in the range of 2-65535 bytes (2 is min HDLC frame 25 * with 1 addr byte and 1 ctrl byte). The max byte count of 65535 26 * should include any crc bytes required. For example, when using 27 * CCITT CRC32, 4 crc bytes are required, so the maximum size frame 28 * the application may transmit is limited to 65531 bytes. For CCITT 29 * CRC16, the maximum application frame size would be 65533. 30 * 31 * 32 * 2. receive callbacks from the device driver represents 33 * one received frame. The device driver should bypass 34 * the tty flip buffer and call the line discipline receive 35 * callback directly to avoid fragmenting or concatenating 36 * multiple frames into a single receive callback. 37 * 38 * The HDLC line discipline queues the receive frames in separate 39 * buffers so complete receive frames can be returned by the 40 * tty read calls. 41 * 42 * 3. tty read calls returns an entire frame of data or nothing. 43 * 44 * 4. all send and receive data is considered raw. No processing 45 * or translation is performed by the line discipline, regardless 46 * of the tty flags 47 * 48 * 5. When line discipline is queried for the amount of receive 49 * data available (FIOC), 0 is returned if no data available, 50 * otherwise the count of the next available frame is returned. 51 * (instead of the sum of all received frame counts). 52 * 53 * These conventions allow the standard tty programming interface 54 * to be used for synchronous HDLC applications when used with 55 * this line discipline (or another line discipline that is frame 56 * oriented such as N_PPP). 57 * 58 * The SyncLink driver (synclink.c) implements both asynchronous 59 * (using standard line discipline N_TTY) and synchronous HDLC 60 * (using N_HDLC) communications, with the latter using the above 61 * conventions. 62 * 63 * This implementation is very basic and does not maintain 64 * any statistics. The main point is to enforce the raw data 65 * and frame orientation of HDLC communications. 66 * 67 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 68 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 69 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 70 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 71 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 72 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 73 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 74 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 75 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 76 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 77 * OF THE POSSIBILITY OF SUCH DAMAGE. 78 */ 79 80#define HDLC_MAGIC 0x239e 81 82#include <linux/module.h> 83#include <linux/init.h> 84#include <linux/kernel.h> 85#include <linux/sched.h> 86#include <linux/types.h> 87#include <linux/fcntl.h> 88#include <linux/interrupt.h> 89#include <linux/ptrace.h> 90 91#undef VERSION 92#define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch)) 93 94#include <linux/poll.h> 95#include <linux/in.h> 96#include <linux/ioctl.h> 97#include <linux/slab.h> 98#include <linux/tty.h> 99#include <linux/errno.h> 100#include <linux/smp_lock.h> 101#include <linux/string.h> /* used in new tty drivers */ 102#include <linux/signal.h> /* used in new tty drivers */ 103#include <linux/if.h> 104#include <linux/bitops.h> 105 106#include <asm/system.h> 107#include <asm/termios.h> 108#include <asm/uaccess.h> 109 110/* 111 * Buffers for individual HDLC frames 112 */ 113#define MAX_HDLC_FRAME_SIZE 65535 114#define DEFAULT_RX_BUF_COUNT 10 115#define MAX_RX_BUF_COUNT 60 116#define DEFAULT_TX_BUF_COUNT 3 117 118struct n_hdlc_buf { 119 struct n_hdlc_buf *link; 120 int count; 121 char buf[1]; 122}; 123 124#define N_HDLC_BUF_SIZE (sizeof(struct n_hdlc_buf) + maxframe) 125 126struct n_hdlc_buf_list { 127 struct n_hdlc_buf *head; 128 struct n_hdlc_buf *tail; 129 int count; 130 spinlock_t spinlock; 131}; 132 133struct n_hdlc { 134 int magic; 135 __u32 flags; 136 struct tty_struct *tty; 137 struct tty_struct *backup_tty; 138 int tbusy; 139 int woke_up; 140 struct n_hdlc_buf *tbuf; 141 struct n_hdlc_buf_list tx_buf_list; 142 struct n_hdlc_buf_list rx_buf_list; 143 struct n_hdlc_buf_list tx_free_buf_list; 144 struct n_hdlc_buf_list rx_free_buf_list; 145}; 146 147/* 148 * HDLC buffer list manipulation functions 149 */ 150static void n_hdlc_buf_list_init(struct n_hdlc_buf_list *list); 151static void n_hdlc_buf_put(struct n_hdlc_buf_list *list, 152 struct n_hdlc_buf *buf); 153static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *list); 154 155/* Local functions */ 156 157static struct n_hdlc *n_hdlc_alloc (void); 158 159/* debug level can be set by insmod for debugging purposes */ 160#define DEBUG_LEVEL_INFO 1 161static int debuglevel; 162 163/* max frame size for memory allocations */ 164static int maxframe = 4096; 165 166/* TTY callbacks */ 167 168static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file, 169 __u8 __user *buf, size_t nr); 170static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file, 171 const unsigned char *buf, size_t nr); 172static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file, 173 unsigned int cmd, unsigned long arg); 174static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp, 175 poll_table *wait); 176static int n_hdlc_tty_open(struct tty_struct *tty); 177static void n_hdlc_tty_close(struct tty_struct *tty); 178static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *cp, 179 char *fp, int count); 180static void n_hdlc_tty_wakeup(struct tty_struct *tty); 181 182#define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f))) 183 184#define tty2n_hdlc(tty) ((struct n_hdlc *) ((tty)->disc_data)) 185#define n_hdlc2tty(n_hdlc) ((n_hdlc)->tty) 186 187static void flush_rx_queue(struct tty_struct *tty) 188{ 189 struct n_hdlc *n_hdlc = tty2n_hdlc(tty); 190 struct n_hdlc_buf *buf; 191 192 while ((buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list))) 193 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, buf); 194} 195 196static void flush_tx_queue(struct tty_struct *tty) 197{ 198 struct n_hdlc *n_hdlc = tty2n_hdlc(tty); 199 struct n_hdlc_buf *buf; 200 unsigned long flags; 201 202 while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list))) 203 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf); 204 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags); 205 if (n_hdlc->tbuf) { 206 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, n_hdlc->tbuf); 207 n_hdlc->tbuf = NULL; 208 } 209 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 210} 211 212static struct tty_ldisc_ops n_hdlc_ldisc = { 213 .owner = THIS_MODULE, 214 .magic = TTY_LDISC_MAGIC, 215 .name = "hdlc", 216 .open = n_hdlc_tty_open, 217 .close = n_hdlc_tty_close, 218 .read = n_hdlc_tty_read, 219 .write = n_hdlc_tty_write, 220 .ioctl = n_hdlc_tty_ioctl, 221 .poll = n_hdlc_tty_poll, 222 .receive_buf = n_hdlc_tty_receive, 223 .write_wakeup = n_hdlc_tty_wakeup, 224 .flush_buffer = flush_rx_queue, 225}; 226 227/** 228 * n_hdlc_release - release an n_hdlc per device line discipline info structure 229 * @n_hdlc - per device line discipline info structure 230 */ 231static void n_hdlc_release(struct n_hdlc *n_hdlc) 232{ 233 struct tty_struct *tty = n_hdlc2tty (n_hdlc); 234 struct n_hdlc_buf *buf; 235 236 if (debuglevel >= DEBUG_LEVEL_INFO) 237 printk("%s(%d)n_hdlc_release() called\n",__FILE__,__LINE__); 238 239 /* Ensure that the n_hdlcd process is not hanging on select()/poll() */ 240 wake_up_interruptible (&tty->read_wait); 241 wake_up_interruptible (&tty->write_wait); 242 243 if (tty->disc_data == n_hdlc) 244 tty->disc_data = NULL; /* Break the tty->n_hdlc link */ 245 246 /* Release transmit and receive buffers */ 247 for(;;) { 248 buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list); 249 if (buf) { 250 kfree(buf); 251 } else 252 break; 253 } 254 for(;;) { 255 buf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list); 256 if (buf) { 257 kfree(buf); 258 } else 259 break; 260 } 261 for(;;) { 262 buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list); 263 if (buf) { 264 kfree(buf); 265 } else 266 break; 267 } 268 for(;;) { 269 buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 270 if (buf) { 271 kfree(buf); 272 } else 273 break; 274 } 275 kfree(n_hdlc->tbuf); 276 kfree(n_hdlc); 277 278} /* end of n_hdlc_release() */ 279 280/** 281 * n_hdlc_tty_close - line discipline close 282 * @tty - pointer to tty info structure 283 * 284 * Called when the line discipline is changed to something 285 * else, the tty is closed, or the tty detects a hangup. 286 */ 287static void n_hdlc_tty_close(struct tty_struct *tty) 288{ 289 struct n_hdlc *n_hdlc = tty2n_hdlc (tty); 290 291 if (debuglevel >= DEBUG_LEVEL_INFO) 292 printk("%s(%d)n_hdlc_tty_close() called\n",__FILE__,__LINE__); 293 294 if (n_hdlc != NULL) { 295 if (n_hdlc->magic != HDLC_MAGIC) { 296 printk (KERN_WARNING"n_hdlc: trying to close unopened tty!\n"); 297 return; 298 } 299#if defined(TTY_NO_WRITE_SPLIT) 300 clear_bit(TTY_NO_WRITE_SPLIT,&tty->flags); 301#endif 302 tty->disc_data = NULL; 303 if (tty == n_hdlc->backup_tty) 304 n_hdlc->backup_tty = NULL; 305 if (tty != n_hdlc->tty) 306 return; 307 if (n_hdlc->backup_tty) { 308 n_hdlc->tty = n_hdlc->backup_tty; 309 } else { 310 n_hdlc_release (n_hdlc); 311 } 312 } 313 314 if (debuglevel >= DEBUG_LEVEL_INFO) 315 printk("%s(%d)n_hdlc_tty_close() success\n",__FILE__,__LINE__); 316 317} /* end of n_hdlc_tty_close() */ 318 319/** 320 * n_hdlc_tty_open - called when line discipline changed to n_hdlc 321 * @tty - pointer to tty info structure 322 * 323 * Returns 0 if success, otherwise error code 324 */ 325static int n_hdlc_tty_open (struct tty_struct *tty) 326{ 327 struct n_hdlc *n_hdlc = tty2n_hdlc (tty); 328 329 if (debuglevel >= DEBUG_LEVEL_INFO) 330 printk("%s(%d)n_hdlc_tty_open() called (device=%s)\n", 331 __FILE__,__LINE__, 332 tty->name); 333 334 /* There should not be an existing table for this slot. */ 335 if (n_hdlc) { 336 printk (KERN_ERR"n_hdlc_tty_open:tty already associated!\n" ); 337 return -EEXIST; 338 } 339 340 n_hdlc = n_hdlc_alloc(); 341 if (!n_hdlc) { 342 printk (KERN_ERR "n_hdlc_alloc failed\n"); 343 return -ENFILE; 344 } 345 346 tty->disc_data = n_hdlc; 347 n_hdlc->tty = tty; 348 tty->receive_room = 65536; 349 350#if defined(TTY_NO_WRITE_SPLIT) 351 /* change tty_io write() to not split large writes into 8K chunks */ 352 set_bit(TTY_NO_WRITE_SPLIT,&tty->flags); 353#endif 354 355 /* flush receive data from driver */ 356 tty_driver_flush_buffer(tty); 357 358 if (debuglevel >= DEBUG_LEVEL_INFO) 359 printk("%s(%d)n_hdlc_tty_open() success\n",__FILE__,__LINE__); 360 361 return 0; 362 363} /* end of n_tty_hdlc_open() */ 364 365/** 366 * n_hdlc_send_frames - send frames on pending send buffer list 367 * @n_hdlc - pointer to ldisc instance data 368 * @tty - pointer to tty instance data 369 * 370 * Send frames on pending send buffer list until the driver does not accept a 371 * frame (busy) this function is called after adding a frame to the send buffer 372 * list and by the tty wakeup callback. 373 */ 374static void n_hdlc_send_frames(struct n_hdlc *n_hdlc, struct tty_struct *tty) 375{ 376 register int actual; 377 unsigned long flags; 378 struct n_hdlc_buf *tbuf; 379 380 if (debuglevel >= DEBUG_LEVEL_INFO) 381 printk("%s(%d)n_hdlc_send_frames() called\n",__FILE__,__LINE__); 382 check_again: 383 384 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags); 385 if (n_hdlc->tbusy) { 386 n_hdlc->woke_up = 1; 387 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 388 return; 389 } 390 n_hdlc->tbusy = 1; 391 n_hdlc->woke_up = 0; 392 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 393 394 /* get current transmit buffer or get new transmit */ 395 /* buffer from list of pending transmit buffers */ 396 397 tbuf = n_hdlc->tbuf; 398 if (!tbuf) 399 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 400 401 while (tbuf) { 402 if (debuglevel >= DEBUG_LEVEL_INFO) 403 printk("%s(%d)sending frame %p, count=%d\n", 404 __FILE__,__LINE__,tbuf,tbuf->count); 405 406 /* Send the next block of data to device */ 407 tty->flags |= (1 << TTY_DO_WRITE_WAKEUP); 408 actual = tty->ops->write(tty, tbuf->buf, tbuf->count); 409 410 /* rollback was possible and has been done */ 411 if (actual == -ERESTARTSYS) { 412 n_hdlc->tbuf = tbuf; 413 break; 414 } 415 /* if transmit error, throw frame away by */ 416 /* pretending it was accepted by driver */ 417 if (actual < 0) 418 actual = tbuf->count; 419 420 if (actual == tbuf->count) { 421 if (debuglevel >= DEBUG_LEVEL_INFO) 422 printk("%s(%d)frame %p completed\n", 423 __FILE__,__LINE__,tbuf); 424 425 /* free current transmit buffer */ 426 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, tbuf); 427 428 /* this tx buffer is done */ 429 n_hdlc->tbuf = NULL; 430 431 /* wait up sleeping writers */ 432 wake_up_interruptible(&tty->write_wait); 433 434 /* get next pending transmit buffer */ 435 tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list); 436 } else { 437 if (debuglevel >= DEBUG_LEVEL_INFO) 438 printk("%s(%d)frame %p pending\n", 439 __FILE__,__LINE__,tbuf); 440 441 /* buffer not accepted by driver */ 442 /* set this buffer as pending buffer */ 443 n_hdlc->tbuf = tbuf; 444 break; 445 } 446 } 447 448 if (!tbuf) 449 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP); 450 451 /* Clear the re-entry flag */ 452 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags); 453 n_hdlc->tbusy = 0; 454 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags); 455 456 if (n_hdlc->woke_up) 457 goto check_again; 458 459 if (debuglevel >= DEBUG_LEVEL_INFO) 460 printk("%s(%d)n_hdlc_send_frames() exit\n",__FILE__,__LINE__); 461 462} /* end of n_hdlc_send_frames() */ 463 464/** 465 * n_hdlc_tty_wakeup - Callback for transmit wakeup 466 * @tty - pointer to associated tty instance data 467 * 468 * Called when low level device driver can accept more send data. 469 */ 470static void n_hdlc_tty_wakeup(struct tty_struct *tty) 471{ 472 struct n_hdlc *n_hdlc = tty2n_hdlc(tty); 473 474 if (debuglevel >= DEBUG_LEVEL_INFO) 475 printk("%s(%d)n_hdlc_tty_wakeup() called\n",__FILE__,__LINE__); 476 477 if (!n_hdlc) 478 return; 479 480 if (tty != n_hdlc->tty) { 481 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP); 482 return; 483 } 484 485 n_hdlc_send_frames (n_hdlc, tty); 486 487} /* end of n_hdlc_tty_wakeup() */ 488 489/** 490 * n_hdlc_tty_receive - Called by tty driver when receive data is available 491 * @tty - pointer to tty instance data 492 * @data - pointer to received data 493 * @flags - pointer to flags for data 494 * @count - count of received data in bytes 495 * 496 * Called by tty low level driver when receive data is available. Data is 497 * interpreted as one HDLC frame. 498 */ 499static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data, 500 char *flags, int count) 501{ 502 register struct n_hdlc *n_hdlc = tty2n_hdlc (tty); 503 register struct n_hdlc_buf *buf; 504 505 if (debuglevel >= DEBUG_LEVEL_INFO) 506 printk("%s(%d)n_hdlc_tty_receive() called count=%d\n", 507 __FILE__,__LINE__, count); 508 509 /* This can happen if stuff comes in on the backup tty */ 510 if (!n_hdlc || tty != n_hdlc->tty) 511 return; 512 513 /* verify line is using HDLC discipline */ 514 if (n_hdlc->magic != HDLC_MAGIC) { 515 printk("%s(%d) line not using HDLC discipline\n", 516 __FILE__,__LINE__); 517 return; 518 } 519 520 if ( count>maxframe ) { 521 if (debuglevel >= DEBUG_LEVEL_INFO) 522 printk("%s(%d) rx count>maxframesize, data discarded\n", 523 __FILE__,__LINE__); 524 return; 525 } 526 527 /* get a free HDLC buffer */ 528 buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list); 529 if (!buf) { 530 /* no buffers in free list, attempt to allocate another rx buffer */ 531 /* unless the maximum count has been reached */ 532 if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT) 533 buf = kmalloc(N_HDLC_BUF_SIZE, GFP_ATOMIC); 534 } 535 536 if (!buf) { 537 if (debuglevel >= DEBUG_LEVEL_INFO) 538 printk("%s(%d) no more rx buffers, data discarded\n", 539 __FILE__,__LINE__); 540 return; 541 } 542 543 /* copy received data to HDLC buffer */ 544 memcpy(buf->buf,data,count); 545 buf->count=count; 546 547 /* add HDLC buffer to list of received frames */ 548 n_hdlc_buf_put(&n_hdlc->rx_buf_list, buf); 549 550 /* wake up any blocked reads and perform async signalling */ 551 wake_up_interruptible (&tty->read_wait); 552 if (n_hdlc->tty->fasync != NULL) 553 kill_fasync (&n_hdlc->tty->fasync, SIGIO, POLL_IN); 554 555} /* end of n_hdlc_tty_receive() */ 556 557/** 558 * n_hdlc_tty_read - Called to retrieve one frame of data (if available) 559 * @tty - pointer to tty instance data 560 * @file - pointer to open file object 561 * @buf - pointer to returned data buffer 562 * @nr - size of returned data buffer 563 * 564 * Returns the number of bytes returned or error code. 565 */ 566static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file, 567 __u8 __user *buf, size_t nr) 568{ 569 struct n_hdlc *n_hdlc = tty2n_hdlc(tty); 570 int ret; 571 struct n_hdlc_buf *rbuf; 572 573 if (debuglevel >= DEBUG_LEVEL_INFO) 574 printk("%s(%d)n_hdlc_tty_read() called\n",__FILE__,__LINE__); 575 576 /* Validate the pointers */ 577 if (!n_hdlc) 578 return -EIO; 579 580 /* verify user access to buffer */ 581 if (!access_ok(VERIFY_WRITE, buf, nr)) { 582 printk(KERN_WARNING "%s(%d) n_hdlc_tty_read() can't verify user " 583 "buffer\n", __FILE__, __LINE__); 584 return -EFAULT; 585 } 586 587 tty_lock(); 588 589 for (;;) { 590 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { 591 tty_unlock(); 592 return -EIO; 593 } 594 595 n_hdlc = tty2n_hdlc (tty); 596 if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC || 597 tty != n_hdlc->tty) { 598 tty_unlock(); 599 return 0; 600 } 601 602 rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list); 603 if (rbuf) 604 break; 605 606 /* no data */ 607 if (file->f_flags & O_NONBLOCK) { 608 tty_unlock(); 609 return -EAGAIN; 610 } 611 612 interruptible_sleep_on (&tty->read_wait); 613 if (signal_pending(current)) { 614 tty_unlock(); 615 return -EINTR; 616 } 617 } 618 619 if (rbuf->count > nr) 620 /* frame too large for caller's buffer (discard frame) */ 621 ret = -EOVERFLOW; 622 else { 623 /* Copy the data to the caller's buffer */ 624 if (copy_to_user(buf, rbuf->buf, rbuf->count)) 625 ret = -EFAULT; 626 else 627 ret = rbuf->count; 628 } 629 630 /* return HDLC buffer to free list unless the free list */ 631 /* count has exceeded the default value, in which case the */ 632 /* buffer is freed back to the OS to conserve memory */ 633 if (n_hdlc->rx_free_buf_list.count > DEFAULT_RX_BUF_COUNT) 634 kfree(rbuf); 635 else 636 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,rbuf); 637 tty_unlock(); 638 return ret; 639 640} /* end of n_hdlc_tty_read() */ 641 642/** 643 * n_hdlc_tty_write - write a single frame of data to device 644 * @tty - pointer to associated tty device instance data 645 * @file - pointer to file object data 646 * @data - pointer to transmit data (one frame) 647 * @count - size of transmit frame in bytes 648 * 649 * Returns the number of bytes written (or error code). 650 */ 651static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file, 652 const unsigned char *data, size_t count) 653{ 654 struct n_hdlc *n_hdlc = tty2n_hdlc (tty); 655 int error = 0; 656 DECLARE_WAITQUEUE(wait, current); 657 struct n_hdlc_buf *tbuf; 658 659 if (debuglevel >= DEBUG_LEVEL_INFO) 660 printk("%s(%d)n_hdlc_tty_write() called count=%Zd\n", 661 __FILE__,__LINE__,count); 662 663 /* Verify pointers */ 664 if (!n_hdlc) 665 return -EIO; 666 667 if (n_hdlc->magic != HDLC_MAGIC) 668 return -EIO; 669 670 /* verify frame size */ 671 if (count > maxframe ) { 672 if (debuglevel & DEBUG_LEVEL_INFO) 673 printk (KERN_WARNING 674 "n_hdlc_tty_write: truncating user packet " 675 "from %lu to %d\n", (unsigned long) count, 676 maxframe ); 677 count = maxframe; 678 } 679 680 tty_lock(); 681 682 add_wait_queue(&tty->write_wait, &wait); 683 set_current_state(TASK_INTERRUPTIBLE); 684 685 /* Allocate transmit buffer */ 686 /* sleep until transmit buffer available */ 687 while (!(tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list))) { 688 if (file->f_flags & O_NONBLOCK) { 689 error = -EAGAIN; 690 break; 691 } 692 schedule(); 693 694 n_hdlc = tty2n_hdlc (tty); 695 if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC || 696 tty != n_hdlc->tty) { 697 printk("n_hdlc_tty_write: %p invalid after wait!\n", n_hdlc); 698 error = -EIO; 699 break; 700 } 701 702 if (signal_pending(current)) { 703 error = -EINTR; 704 break; 705 } 706 } 707 708 set_current_state(TASK_RUNNING); 709 remove_wait_queue(&tty->write_wait, &wait); 710 711 if (!error) { 712 /* Retrieve the user's buffer */ 713 memcpy(tbuf->buf, data, count); 714 715 /* Send the data */ 716 tbuf->count = error = count; 717 n_hdlc_buf_put(&n_hdlc->tx_buf_list,tbuf); 718 n_hdlc_send_frames(n_hdlc,tty); 719 } 720 tty_unlock(); 721 return error; 722 723} /* end of n_hdlc_tty_write() */ 724 725/** 726 * n_hdlc_tty_ioctl - process IOCTL system call for the tty device. 727 * @tty - pointer to tty instance data 728 * @file - pointer to open file object for device 729 * @cmd - IOCTL command code 730 * @arg - argument for IOCTL call (cmd dependent) 731 * 732 * Returns command dependent result. 733 */ 734static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file, 735 unsigned int cmd, unsigned long arg) 736{ 737 struct n_hdlc *n_hdlc = tty2n_hdlc (tty); 738 int error = 0; 739 int count; 740 unsigned long flags; 741 742 if (debuglevel >= DEBUG_LEVEL_INFO) 743 printk("%s(%d)n_hdlc_tty_ioctl() called %d\n", 744 __FILE__,__LINE__,cmd); 745 746 /* Verify the status of the device */ 747 if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC) 748 return -EBADF; 749 750 switch (cmd) { 751 case FIONREAD: 752 /* report count of read data available */ 753 /* in next available frame (if any) */ 754 spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags); 755 if (n_hdlc->rx_buf_list.head) 756 count = n_hdlc->rx_buf_list.head->count; 757 else 758 count = 0; 759 spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock,flags); 760 error = put_user(count, (int __user *)arg); 761 break; 762 763 case TIOCOUTQ: 764 /* get the pending tx byte count in the driver */ 765 count = tty_chars_in_buffer(tty); 766 /* add size of next output frame in queue */ 767 spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags); 768 if (n_hdlc->tx_buf_list.head) 769 count += n_hdlc->tx_buf_list.head->count; 770 spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags); 771 error = put_user(count, (int __user *)arg); 772 break; 773 774 case TCFLSH: 775 switch (arg) { 776 case TCIOFLUSH: 777 case TCOFLUSH: 778 flush_tx_queue(tty); 779 } 780 /* fall through to default */ 781 782 default: 783 error = n_tty_ioctl_helper(tty, file, cmd, arg); 784 break; 785 } 786 return error; 787 788} /* end of n_hdlc_tty_ioctl() */ 789 790/** 791 * n_hdlc_tty_poll - TTY callback for poll system call 792 * @tty - pointer to tty instance data 793 * @filp - pointer to open file object for device 794 * @poll_table - wait queue for operations 795 * 796 * Determine which operations (read/write) will not block and return info 797 * to caller. 798 * Returns a bit mask containing info on which ops will not block. 799 */ 800static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp, 801 poll_table *wait) 802{ 803 struct n_hdlc *n_hdlc = tty2n_hdlc (tty); 804 unsigned int mask = 0; 805 806 if (debuglevel >= DEBUG_LEVEL_INFO) 807 printk("%s(%d)n_hdlc_tty_poll() called\n",__FILE__,__LINE__); 808 809 if (n_hdlc && n_hdlc->magic == HDLC_MAGIC && tty == n_hdlc->tty) { 810 /* queue current process into any wait queue that */ 811 /* may awaken in the future (read and write) */ 812 813 poll_wait(filp, &tty->read_wait, wait); 814 poll_wait(filp, &tty->write_wait, wait); 815 816 /* set bits for operations that won't block */ 817 if (n_hdlc->rx_buf_list.head) 818 mask |= POLLIN | POLLRDNORM; /* readable */ 819 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) 820 mask |= POLLHUP; 821 if (tty_hung_up_p(filp)) 822 mask |= POLLHUP; 823 if (!tty_is_writelocked(tty) && 824 n_hdlc->tx_free_buf_list.head) 825 mask |= POLLOUT | POLLWRNORM; /* writable */ 826 } 827 return mask; 828} /* end of n_hdlc_tty_poll() */ 829 830/** 831 * n_hdlc_alloc - allocate an n_hdlc instance data structure 832 * 833 * Returns a pointer to newly created structure if success, otherwise %NULL 834 */ 835static struct n_hdlc *n_hdlc_alloc(void) 836{ 837 struct n_hdlc_buf *buf; 838 int i; 839 struct n_hdlc *n_hdlc = kmalloc(sizeof(*n_hdlc), GFP_KERNEL); 840 841 if (!n_hdlc) 842 return NULL; 843 844 memset(n_hdlc, 0, sizeof(*n_hdlc)); 845 846 n_hdlc_buf_list_init(&n_hdlc->rx_free_buf_list); 847 n_hdlc_buf_list_init(&n_hdlc->tx_free_buf_list); 848 n_hdlc_buf_list_init(&n_hdlc->rx_buf_list); 849 n_hdlc_buf_list_init(&n_hdlc->tx_buf_list); 850 851 /* allocate free rx buffer list */ 852 for(i=0;i<DEFAULT_RX_BUF_COUNT;i++) { 853 buf = kmalloc(N_HDLC_BUF_SIZE, GFP_KERNEL); 854 if (buf) 855 n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,buf); 856 else if (debuglevel >= DEBUG_LEVEL_INFO) 857 printk("%s(%d)n_hdlc_alloc(), kalloc() failed for rx buffer %d\n",__FILE__,__LINE__, i); 858 } 859 860 /* allocate free tx buffer list */ 861 for(i=0;i<DEFAULT_TX_BUF_COUNT;i++) { 862 buf = kmalloc(N_HDLC_BUF_SIZE, GFP_KERNEL); 863 if (buf) 864 n_hdlc_buf_put(&n_hdlc->tx_free_buf_list,buf); 865 else if (debuglevel >= DEBUG_LEVEL_INFO) 866 printk("%s(%d)n_hdlc_alloc(), kalloc() failed for tx buffer %d\n",__FILE__,__LINE__, i); 867 } 868 869 /* Initialize the control block */ 870 n_hdlc->magic = HDLC_MAGIC; 871 n_hdlc->flags = 0; 872 873 return n_hdlc; 874 875} /* end of n_hdlc_alloc() */ 876 877/** 878 * n_hdlc_buf_list_init - initialize specified HDLC buffer list 879 * @list - pointer to buffer list 880 */ 881static void n_hdlc_buf_list_init(struct n_hdlc_buf_list *list) 882{ 883 memset(list, 0, sizeof(*list)); 884 spin_lock_init(&list->spinlock); 885} /* end of n_hdlc_buf_list_init() */ 886 887/** 888 * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list 889 * @list - pointer to buffer list 890 * @buf - pointer to buffer 891 */ 892static void n_hdlc_buf_put(struct n_hdlc_buf_list *list, 893 struct n_hdlc_buf *buf) 894{ 895 unsigned long flags; 896 spin_lock_irqsave(&list->spinlock,flags); 897 898 buf->link=NULL; 899 if (list->tail) 900 list->tail->link = buf; 901 else 902 list->head = buf; 903 list->tail = buf; 904 (list->count)++; 905 906 spin_unlock_irqrestore(&list->spinlock,flags); 907 908} /* end of n_hdlc_buf_put() */ 909 910/** 911 * n_hdlc_buf_get - remove and return an HDLC buffer from list 912 * @list - pointer to HDLC buffer list 913 * 914 * Remove and return an HDLC buffer from the head of the specified HDLC buffer 915 * list. 916 * Returns a pointer to HDLC buffer if available, otherwise %NULL. 917 */ 918static struct n_hdlc_buf* n_hdlc_buf_get(struct n_hdlc_buf_list *list) 919{ 920 unsigned long flags; 921 struct n_hdlc_buf *buf; 922 spin_lock_irqsave(&list->spinlock,flags); 923 924 buf = list->head; 925 if (buf) { 926 list->head = buf->link; 927 (list->count)--; 928 } 929 if (!list->head) 930 list->tail = NULL; 931 932 spin_unlock_irqrestore(&list->spinlock,flags); 933 return buf; 934 935} /* end of n_hdlc_buf_get() */ 936 937static char hdlc_banner[] __initdata = 938 KERN_INFO "HDLC line discipline maxframe=%u\n"; 939static char hdlc_register_ok[] __initdata = 940 KERN_INFO "N_HDLC line discipline registered.\n"; 941static char hdlc_register_fail[] __initdata = 942 KERN_ERR "error registering line discipline: %d\n"; 943static char hdlc_init_fail[] __initdata = 944 KERN_INFO "N_HDLC: init failure %d\n"; 945 946static int __init n_hdlc_init(void) 947{ 948 int status; 949 950 /* range check maxframe arg */ 951 if (maxframe < 4096) 952 maxframe = 4096; 953 else if (maxframe > 65535) 954 maxframe = 65535; 955 956 printk(hdlc_banner, maxframe); 957 958 status = tty_register_ldisc(N_HDLC, &n_hdlc_ldisc); 959 if (!status) 960 printk(hdlc_register_ok); 961 else 962 printk(hdlc_register_fail, status); 963 964 if (status) 965 printk(hdlc_init_fail, status); 966 return status; 967 968} /* end of init_module() */ 969 970static char hdlc_unregister_ok[] __exitdata = 971 KERN_INFO "N_HDLC: line discipline unregistered\n"; 972static char hdlc_unregister_fail[] __exitdata = 973 KERN_ERR "N_HDLC: can't unregister line discipline (err = %d)\n"; 974 975static void __exit n_hdlc_exit(void) 976{ 977 /* Release tty registration of line discipline */ 978 int status = tty_unregister_ldisc(N_HDLC); 979 980 if (status) 981 printk(hdlc_unregister_fail, status); 982 else 983 printk(hdlc_unregister_ok); 984} 985 986module_init(n_hdlc_init); 987module_exit(n_hdlc_exit); 988 989MODULE_LICENSE("GPL"); 990MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com"); 991module_param(debuglevel, int, 0); 992module_param(maxframe, int, 0); 993MODULE_ALIAS_LDISC(N_HDLC); 994