1/* 2 * Things to sort out: 3 * 4 * o tbusy handling 5 * o allow users to set the parameters 6 * o sync/async switching ? 7 * 8 * Note: This does _not_ implement CCITT X.25 asynchronous framing 9 * recommendations. Its primarily for testing purposes. If you wanted 10 * to do CCITT then in theory all you need is to nick the HDLC async 11 * checksum routines from ppp.c 12 * Changes: 13 * 14 * 2000-10-29 Henner Eisen lapb_data_indication() return status. 15 */ 16 17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19#include <linux/module.h> 20 21#include <linux/uaccess.h> 22#include <linux/bitops.h> 23#include <linux/string.h> 24#include <linux/mm.h> 25#include <linux/interrupt.h> 26#include <linux/in.h> 27#include <linux/tty.h> 28#include <linux/errno.h> 29#include <linux/netdevice.h> 30#include <linux/etherdevice.h> 31#include <linux/skbuff.h> 32#include <linux/if_arp.h> 33#include <linux/lapb.h> 34#include <linux/init.h> 35#include <linux/rtnetlink.h> 36#include <linux/compat.h> 37#include <linux/slab.h> 38#include <net/x25device.h> 39#include "x25_asy.h" 40 41static struct net_device **x25_asy_devs; 42static int x25_asy_maxdev = SL_NRUNIT; 43 44module_param(x25_asy_maxdev, int, 0); 45MODULE_LICENSE("GPL"); 46 47static int x25_asy_esc(unsigned char *p, unsigned char *d, int len); 48static void x25_asy_unesc(struct x25_asy *sl, unsigned char c); 49static void x25_asy_setup(struct net_device *dev); 50 51/* Find a free X.25 channel, and link in this `tty' line. */ 52static struct x25_asy *x25_asy_alloc(void) 53{ 54 struct net_device *dev = NULL; 55 struct x25_asy *sl; 56 int i; 57 58 if (x25_asy_devs == NULL) 59 return NULL; /* Master array missing ! */ 60 61 for (i = 0; i < x25_asy_maxdev; i++) { 62 dev = x25_asy_devs[i]; 63 64 /* Not allocated ? */ 65 if (dev == NULL) 66 break; 67 68 sl = netdev_priv(dev); 69 /* Not in use ? */ 70 if (!test_and_set_bit(SLF_INUSE, &sl->flags)) 71 return sl; 72 } 73 74 75 /* Sorry, too many, all slots in use */ 76 if (i >= x25_asy_maxdev) 77 return NULL; 78 79 /* If no channels are available, allocate one */ 80 if (!dev) { 81 char name[IFNAMSIZ]; 82 sprintf(name, "x25asy%d", i); 83 84 dev = alloc_netdev(sizeof(struct x25_asy), name, 85 NET_NAME_UNKNOWN, x25_asy_setup); 86 if (!dev) 87 return NULL; 88 89 /* Initialize channel control data */ 90 sl = netdev_priv(dev); 91 dev->base_addr = i; 92 93 /* register device so that it can be ifconfig'ed */ 94 if (register_netdev(dev) == 0) { 95 /* (Re-)Set the INUSE bit. Very Important! */ 96 set_bit(SLF_INUSE, &sl->flags); 97 x25_asy_devs[i] = dev; 98 return sl; 99 } else { 100 pr_warn("%s(): register_netdev() failure\n", __func__); 101 free_netdev(dev); 102 } 103 } 104 return NULL; 105} 106 107 108/* Free an X.25 channel. */ 109static void x25_asy_free(struct x25_asy *sl) 110{ 111 /* Free all X.25 frame buffers. */ 112 kfree(sl->rbuff); 113 sl->rbuff = NULL; 114 kfree(sl->xbuff); 115 sl->xbuff = NULL; 116 117 if (!test_and_clear_bit(SLF_INUSE, &sl->flags)) 118 netdev_err(sl->dev, "x25_asy_free for already free unit\n"); 119} 120 121static int x25_asy_change_mtu(struct net_device *dev, int newmtu) 122{ 123 struct x25_asy *sl = netdev_priv(dev); 124 unsigned char *xbuff, *rbuff; 125 int len; 126 127 if (newmtu > 65534) 128 return -EINVAL; 129 130 len = 2 * newmtu; 131 xbuff = kmalloc(len + 4, GFP_ATOMIC); 132 rbuff = kmalloc(len + 4, GFP_ATOMIC); 133 134 if (xbuff == NULL || rbuff == NULL) { 135 kfree(xbuff); 136 kfree(rbuff); 137 return -ENOMEM; 138 } 139 140 spin_lock_bh(&sl->lock); 141 xbuff = xchg(&sl->xbuff, xbuff); 142 if (sl->xleft) { 143 if (sl->xleft <= len) { 144 memcpy(sl->xbuff, sl->xhead, sl->xleft); 145 } else { 146 sl->xleft = 0; 147 dev->stats.tx_dropped++; 148 } 149 } 150 sl->xhead = sl->xbuff; 151 152 rbuff = xchg(&sl->rbuff, rbuff); 153 if (sl->rcount) { 154 if (sl->rcount <= len) { 155 memcpy(sl->rbuff, rbuff, sl->rcount); 156 } else { 157 sl->rcount = 0; 158 dev->stats.rx_over_errors++; 159 set_bit(SLF_ERROR, &sl->flags); 160 } 161 } 162 163 dev->mtu = newmtu; 164 sl->buffsize = len; 165 166 spin_unlock_bh(&sl->lock); 167 168 kfree(xbuff); 169 kfree(rbuff); 170 return 0; 171} 172 173 174/* Set the "sending" flag. This must be atomic, hence the ASM. */ 175 176static inline void x25_asy_lock(struct x25_asy *sl) 177{ 178 netif_stop_queue(sl->dev); 179} 180 181 182/* Clear the "sending" flag. This must be atomic, hence the ASM. */ 183 184static inline void x25_asy_unlock(struct x25_asy *sl) 185{ 186 netif_wake_queue(sl->dev); 187} 188 189/* Send one completely decapsulated IP datagram to the IP layer. */ 190 191static void x25_asy_bump(struct x25_asy *sl) 192{ 193 struct net_device *dev = sl->dev; 194 struct sk_buff *skb; 195 int count; 196 int err; 197 198 count = sl->rcount; 199 dev->stats.rx_bytes += count; 200 201 skb = dev_alloc_skb(count+1); 202 if (skb == NULL) { 203 netdev_warn(sl->dev, "memory squeeze, dropping packet\n"); 204 dev->stats.rx_dropped++; 205 return; 206 } 207 skb_push(skb, 1); /* LAPB internal control */ 208 memcpy(skb_put(skb, count), sl->rbuff, count); 209 skb->protocol = x25_type_trans(skb, sl->dev); 210 err = lapb_data_received(skb->dev, skb); 211 if (err != LAPB_OK) { 212 kfree_skb(skb); 213 printk(KERN_DEBUG "x25_asy: data received err - %d\n", err); 214 } else { 215 netif_rx(skb); 216 dev->stats.rx_packets++; 217 } 218} 219 220/* Encapsulate one IP datagram and stuff into a TTY queue. */ 221static void x25_asy_encaps(struct x25_asy *sl, unsigned char *icp, int len) 222{ 223 unsigned char *p; 224 int actual, count, mtu = sl->dev->mtu; 225 226 if (len > mtu) { 227 /* Sigh, shouldn't occur BUT ... */ 228 len = mtu; 229 printk(KERN_DEBUG "%s: truncating oversized transmit packet!\n", 230 sl->dev->name); 231 sl->dev->stats.tx_dropped++; 232 x25_asy_unlock(sl); 233 return; 234 } 235 236 p = icp; 237 count = x25_asy_esc(p, sl->xbuff, len); 238 239 /* Order of next two lines is *very* important. 240 * When we are sending a little amount of data, 241 * the transfer may be completed inside driver.write() 242 * routine, because it's running with interrupts enabled. 243 * In this case we *never* got WRITE_WAKEUP event, 244 * if we did not request it before write operation. 245 * 14 Oct 1994 Dmitry Gorodchanin. 246 */ 247 set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 248 actual = sl->tty->ops->write(sl->tty, sl->xbuff, count); 249 sl->xleft = count - actual; 250 sl->xhead = sl->xbuff + actual; 251 /* VSV */ 252 clear_bit(SLF_OUTWAIT, &sl->flags); /* reset outfill flag */ 253} 254 255/* 256 * Called by the driver when there's room for more data. If we have 257 * more packets to send, we send them here. 258 */ 259static void x25_asy_write_wakeup(struct tty_struct *tty) 260{ 261 int actual; 262 struct x25_asy *sl = tty->disc_data; 263 264 /* First make sure we're connected. */ 265 if (!sl || sl->magic != X25_ASY_MAGIC || !netif_running(sl->dev)) 266 return; 267 268 if (sl->xleft <= 0) { 269 /* Now serial buffer is almost free & we can start 270 * transmission of another packet */ 271 sl->dev->stats.tx_packets++; 272 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 273 x25_asy_unlock(sl); 274 return; 275 } 276 277 actual = tty->ops->write(tty, sl->xhead, sl->xleft); 278 sl->xleft -= actual; 279 sl->xhead += actual; 280} 281 282static void x25_asy_timeout(struct net_device *dev) 283{ 284 struct x25_asy *sl = netdev_priv(dev); 285 286 spin_lock(&sl->lock); 287 if (netif_queue_stopped(dev)) { 288 /* May be we must check transmitter timeout here ? 289 * 14 Oct 1994 Dmitry Gorodchanin. 290 */ 291 netdev_warn(dev, "transmit timed out, %s?\n", 292 (tty_chars_in_buffer(sl->tty) || sl->xleft) ? 293 "bad line quality" : "driver error"); 294 sl->xleft = 0; 295 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 296 x25_asy_unlock(sl); 297 } 298 spin_unlock(&sl->lock); 299} 300 301/* Encapsulate an IP datagram and kick it into a TTY queue. */ 302 303static netdev_tx_t x25_asy_xmit(struct sk_buff *skb, 304 struct net_device *dev) 305{ 306 struct x25_asy *sl = netdev_priv(dev); 307 int err; 308 309 if (!netif_running(sl->dev)) { 310 netdev_err(dev, "xmit call when iface is down\n"); 311 kfree_skb(skb); 312 return NETDEV_TX_OK; 313 } 314 315 switch (skb->data[0]) { 316 case X25_IFACE_DATA: 317 break; 318 case X25_IFACE_CONNECT: /* Connection request .. do nothing */ 319 err = lapb_connect_request(dev); 320 if (err != LAPB_OK) 321 netdev_err(dev, "lapb_connect_request error: %d\n", 322 err); 323 kfree_skb(skb); 324 return NETDEV_TX_OK; 325 case X25_IFACE_DISCONNECT: /* do nothing - hang up ?? */ 326 err = lapb_disconnect_request(dev); 327 if (err != LAPB_OK) 328 netdev_err(dev, "lapb_disconnect_request error: %d\n", 329 err); 330 default: 331 kfree_skb(skb); 332 return NETDEV_TX_OK; 333 } 334 skb_pull(skb, 1); /* Remove control byte */ 335 /* 336 * If we are busy already- too bad. We ought to be able 337 * to queue things at this point, to allow for a little 338 * frame buffer. Oh well... 339 * ----------------------------------------------------- 340 * I hate queues in X.25 driver. May be it's efficient, 341 * but for me latency is more important. ;) 342 * So, no queues ! 343 * 14 Oct 1994 Dmitry Gorodchanin. 344 */ 345 346 err = lapb_data_request(dev, skb); 347 if (err != LAPB_OK) { 348 netdev_err(dev, "lapb_data_request error: %d\n", err); 349 kfree_skb(skb); 350 return NETDEV_TX_OK; 351 } 352 return NETDEV_TX_OK; 353} 354 355 356/* 357 * LAPB interface boilerplate 358 */ 359 360/* 361 * Called when I frame data arrives. We did the work above - throw it 362 * at the net layer. 363 */ 364 365static int x25_asy_data_indication(struct net_device *dev, struct sk_buff *skb) 366{ 367 return netif_rx(skb); 368} 369 370/* 371 * Data has emerged from the LAPB protocol machine. We don't handle 372 * busy cases too well. Its tricky to see how to do this nicely - 373 * perhaps lapb should allow us to bounce this ? 374 */ 375 376static void x25_asy_data_transmit(struct net_device *dev, struct sk_buff *skb) 377{ 378 struct x25_asy *sl = netdev_priv(dev); 379 380 spin_lock(&sl->lock); 381 if (netif_queue_stopped(sl->dev) || sl->tty == NULL) { 382 spin_unlock(&sl->lock); 383 netdev_err(dev, "tbusy drop\n"); 384 kfree_skb(skb); 385 return; 386 } 387 /* We were not busy, so we are now... :-) */ 388 if (skb != NULL) { 389 x25_asy_lock(sl); 390 dev->stats.tx_bytes += skb->len; 391 x25_asy_encaps(sl, skb->data, skb->len); 392 dev_kfree_skb(skb); 393 } 394 spin_unlock(&sl->lock); 395} 396 397/* 398 * LAPB connection establish/down information. 399 */ 400 401static void x25_asy_connected(struct net_device *dev, int reason) 402{ 403 struct x25_asy *sl = netdev_priv(dev); 404 struct sk_buff *skb; 405 unsigned char *ptr; 406 407 skb = dev_alloc_skb(1); 408 if (skb == NULL) { 409 netdev_err(dev, "out of memory\n"); 410 return; 411 } 412 413 ptr = skb_put(skb, 1); 414 *ptr = X25_IFACE_CONNECT; 415 416 skb->protocol = x25_type_trans(skb, sl->dev); 417 netif_rx(skb); 418} 419 420static void x25_asy_disconnected(struct net_device *dev, int reason) 421{ 422 struct x25_asy *sl = netdev_priv(dev); 423 struct sk_buff *skb; 424 unsigned char *ptr; 425 426 skb = dev_alloc_skb(1); 427 if (skb == NULL) { 428 netdev_err(dev, "out of memory\n"); 429 return; 430 } 431 432 ptr = skb_put(skb, 1); 433 *ptr = X25_IFACE_DISCONNECT; 434 435 skb->protocol = x25_type_trans(skb, sl->dev); 436 netif_rx(skb); 437} 438 439static const struct lapb_register_struct x25_asy_callbacks = { 440 .connect_confirmation = x25_asy_connected, 441 .connect_indication = x25_asy_connected, 442 .disconnect_confirmation = x25_asy_disconnected, 443 .disconnect_indication = x25_asy_disconnected, 444 .data_indication = x25_asy_data_indication, 445 .data_transmit = x25_asy_data_transmit, 446}; 447 448 449/* Open the low-level part of the X.25 channel. Easy! */ 450static int x25_asy_open(struct net_device *dev) 451{ 452 struct x25_asy *sl = netdev_priv(dev); 453 unsigned long len; 454 int err; 455 456 if (sl->tty == NULL) 457 return -ENODEV; 458 459 /* 460 * Allocate the X.25 frame buffers: 461 * 462 * rbuff Receive buffer. 463 * xbuff Transmit buffer. 464 */ 465 466 len = dev->mtu * 2; 467 468 sl->rbuff = kmalloc(len + 4, GFP_KERNEL); 469 if (sl->rbuff == NULL) 470 goto norbuff; 471 sl->xbuff = kmalloc(len + 4, GFP_KERNEL); 472 if (sl->xbuff == NULL) 473 goto noxbuff; 474 475 sl->buffsize = len; 476 sl->rcount = 0; 477 sl->xleft = 0; 478 sl->flags &= (1 << SLF_INUSE); /* Clear ESCAPE & ERROR flags */ 479 480 netif_start_queue(dev); 481 482 /* 483 * Now attach LAPB 484 */ 485 err = lapb_register(dev, &x25_asy_callbacks); 486 if (err == LAPB_OK) 487 return 0; 488 489 /* Cleanup */ 490 kfree(sl->xbuff); 491noxbuff: 492 kfree(sl->rbuff); 493norbuff: 494 return -ENOMEM; 495} 496 497 498/* Close the low-level part of the X.25 channel. Easy! */ 499static int x25_asy_close(struct net_device *dev) 500{ 501 struct x25_asy *sl = netdev_priv(dev); 502 503 spin_lock(&sl->lock); 504 if (sl->tty) 505 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 506 507 netif_stop_queue(dev); 508 sl->rcount = 0; 509 sl->xleft = 0; 510 spin_unlock(&sl->lock); 511 return 0; 512} 513 514/* 515 * Handle the 'receiver data ready' interrupt. 516 * This function is called by the 'tty_io' module in the kernel when 517 * a block of X.25 data has been received, which can now be decapsulated 518 * and sent on to some IP layer for further processing. 519 */ 520 521static void x25_asy_receive_buf(struct tty_struct *tty, 522 const unsigned char *cp, char *fp, int count) 523{ 524 struct x25_asy *sl = tty->disc_data; 525 526 if (!sl || sl->magic != X25_ASY_MAGIC || !netif_running(sl->dev)) 527 return; 528 529 530 /* Read the characters out of the buffer */ 531 while (count--) { 532 if (fp && *fp++) { 533 if (!test_and_set_bit(SLF_ERROR, &sl->flags)) 534 sl->dev->stats.rx_errors++; 535 cp++; 536 continue; 537 } 538 x25_asy_unesc(sl, *cp++); 539 } 540} 541 542/* 543 * Open the high-level part of the X.25 channel. 544 * This function is called by the TTY module when the 545 * X.25 line discipline is called for. Because we are 546 * sure the tty line exists, we only have to link it to 547 * a free X.25 channel... 548 */ 549 550static int x25_asy_open_tty(struct tty_struct *tty) 551{ 552 struct x25_asy *sl = tty->disc_data; 553 int err; 554 555 if (tty->ops->write == NULL) 556 return -EOPNOTSUPP; 557 558 /* First make sure we're not already connected. */ 559 if (sl && sl->magic == X25_ASY_MAGIC) 560 return -EEXIST; 561 562 /* OK. Find a free X.25 channel to use. */ 563 sl = x25_asy_alloc(); 564 if (sl == NULL) 565 return -ENFILE; 566 567 sl->tty = tty; 568 tty->disc_data = sl; 569 tty->receive_room = 65536; 570 tty_driver_flush_buffer(tty); 571 tty_ldisc_flush(tty); 572 573 /* Restore default settings */ 574 sl->dev->type = ARPHRD_X25; 575 576 /* Perform the low-level X.25 async init */ 577 err = x25_asy_open(sl->dev); 578 if (err) 579 return err; 580 /* Done. We have linked the TTY line to a channel. */ 581 return 0; 582} 583 584 585/* 586 * Close down an X.25 channel. 587 * This means flushing out any pending queues, and then restoring the 588 * TTY line discipline to what it was before it got hooked to X.25 589 * (which usually is TTY again). 590 */ 591static void x25_asy_close_tty(struct tty_struct *tty) 592{ 593 struct x25_asy *sl = tty->disc_data; 594 int err; 595 596 /* First make sure we're connected. */ 597 if (!sl || sl->magic != X25_ASY_MAGIC) 598 return; 599 600 rtnl_lock(); 601 if (sl->dev->flags & IFF_UP) 602 dev_close(sl->dev); 603 rtnl_unlock(); 604 605 err = lapb_unregister(sl->dev); 606 if (err != LAPB_OK) 607 pr_err("x25_asy_close: lapb_unregister error: %d\n", 608 err); 609 610 tty->disc_data = NULL; 611 sl->tty = NULL; 612 x25_asy_free(sl); 613} 614 615 /************************************************************************ 616 * STANDARD X.25 ENCAPSULATION * 617 ************************************************************************/ 618 619static int x25_asy_esc(unsigned char *s, unsigned char *d, int len) 620{ 621 unsigned char *ptr = d; 622 unsigned char c; 623 624 /* 625 * Send an initial END character to flush out any 626 * data that may have accumulated in the receiver 627 * due to line noise. 628 */ 629 630 *ptr++ = X25_END; /* Send 10111110 bit seq */ 631 632 /* 633 * For each byte in the packet, send the appropriate 634 * character sequence, according to the X.25 protocol. 635 */ 636 637 while (len-- > 0) { 638 switch (c = *s++) { 639 case X25_END: 640 *ptr++ = X25_ESC; 641 *ptr++ = X25_ESCAPE(X25_END); 642 break; 643 case X25_ESC: 644 *ptr++ = X25_ESC; 645 *ptr++ = X25_ESCAPE(X25_ESC); 646 break; 647 default: 648 *ptr++ = c; 649 break; 650 } 651 } 652 *ptr++ = X25_END; 653 return ptr - d; 654} 655 656static void x25_asy_unesc(struct x25_asy *sl, unsigned char s) 657{ 658 659 switch (s) { 660 case X25_END: 661 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && 662 sl->rcount > 2) 663 x25_asy_bump(sl); 664 clear_bit(SLF_ESCAPE, &sl->flags); 665 sl->rcount = 0; 666 return; 667 case X25_ESC: 668 set_bit(SLF_ESCAPE, &sl->flags); 669 return; 670 case X25_ESCAPE(X25_ESC): 671 case X25_ESCAPE(X25_END): 672 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags)) 673 s = X25_UNESCAPE(s); 674 break; 675 } 676 if (!test_bit(SLF_ERROR, &sl->flags)) { 677 if (sl->rcount < sl->buffsize) { 678 sl->rbuff[sl->rcount++] = s; 679 return; 680 } 681 sl->dev->stats.rx_over_errors++; 682 set_bit(SLF_ERROR, &sl->flags); 683 } 684} 685 686 687/* Perform I/O control on an active X.25 channel. */ 688static int x25_asy_ioctl(struct tty_struct *tty, struct file *file, 689 unsigned int cmd, unsigned long arg) 690{ 691 struct x25_asy *sl = tty->disc_data; 692 693 /* First make sure we're connected. */ 694 if (!sl || sl->magic != X25_ASY_MAGIC) 695 return -EINVAL; 696 697 switch (cmd) { 698 case SIOCGIFNAME: 699 if (copy_to_user((void __user *)arg, sl->dev->name, 700 strlen(sl->dev->name) + 1)) 701 return -EFAULT; 702 return 0; 703 case SIOCSIFHWADDR: 704 return -EINVAL; 705 default: 706 return tty_mode_ioctl(tty, file, cmd, arg); 707 } 708} 709 710#ifdef CONFIG_COMPAT 711static long x25_asy_compat_ioctl(struct tty_struct *tty, struct file *file, 712 unsigned int cmd, unsigned long arg) 713{ 714 switch (cmd) { 715 case SIOCGIFNAME: 716 case SIOCSIFHWADDR: 717 return x25_asy_ioctl(tty, file, cmd, 718 (unsigned long)compat_ptr(arg)); 719 } 720 721 return -ENOIOCTLCMD; 722} 723#endif 724 725static int x25_asy_open_dev(struct net_device *dev) 726{ 727 struct x25_asy *sl = netdev_priv(dev); 728 if (sl->tty == NULL) 729 return -ENODEV; 730 return 0; 731} 732 733static const struct net_device_ops x25_asy_netdev_ops = { 734 .ndo_open = x25_asy_open_dev, 735 .ndo_stop = x25_asy_close, 736 .ndo_start_xmit = x25_asy_xmit, 737 .ndo_tx_timeout = x25_asy_timeout, 738 .ndo_change_mtu = x25_asy_change_mtu, 739}; 740 741/* Initialise the X.25 driver. Called by the device init code */ 742static void x25_asy_setup(struct net_device *dev) 743{ 744 struct x25_asy *sl = netdev_priv(dev); 745 746 sl->magic = X25_ASY_MAGIC; 747 sl->dev = dev; 748 spin_lock_init(&sl->lock); 749 set_bit(SLF_INUSE, &sl->flags); 750 751 /* 752 * Finish setting up the DEVICE info. 753 */ 754 755 dev->mtu = SL_MTU; 756 dev->netdev_ops = &x25_asy_netdev_ops; 757 dev->watchdog_timeo = HZ*20; 758 dev->hard_header_len = 0; 759 dev->addr_len = 0; 760 dev->type = ARPHRD_X25; 761 dev->tx_queue_len = 10; 762 763 /* New-style flags. */ 764 dev->flags = IFF_NOARP; 765} 766 767static struct tty_ldisc_ops x25_ldisc = { 768 .owner = THIS_MODULE, 769 .magic = TTY_LDISC_MAGIC, 770 .name = "X.25", 771 .open = x25_asy_open_tty, 772 .close = x25_asy_close_tty, 773 .ioctl = x25_asy_ioctl, 774#ifdef CONFIG_COMPAT 775 .compat_ioctl = x25_asy_compat_ioctl, 776#endif 777 .receive_buf = x25_asy_receive_buf, 778 .write_wakeup = x25_asy_write_wakeup, 779}; 780 781static int __init init_x25_asy(void) 782{ 783 if (x25_asy_maxdev < 4) 784 x25_asy_maxdev = 4; /* Sanity */ 785 786 pr_info("X.25 async: version 0.00 ALPHA (dynamic channels, max=%d)\n", 787 x25_asy_maxdev); 788 789 x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device *), 790 GFP_KERNEL); 791 if (!x25_asy_devs) 792 return -ENOMEM; 793 794 return tty_register_ldisc(N_X25, &x25_ldisc); 795} 796 797 798static void __exit exit_x25_asy(void) 799{ 800 struct net_device *dev; 801 int i; 802 803 for (i = 0; i < x25_asy_maxdev; i++) { 804 dev = x25_asy_devs[i]; 805 if (dev) { 806 struct x25_asy *sl = netdev_priv(dev); 807 808 spin_lock_bh(&sl->lock); 809 if (sl->tty) 810 tty_hangup(sl->tty); 811 812 spin_unlock_bh(&sl->lock); 813 /* 814 * VSV = if dev->start==0, then device 815 * unregistered while close proc. 816 */ 817 unregister_netdev(dev); 818 free_netdev(dev); 819 } 820 } 821 822 kfree(x25_asy_devs); 823 tty_unregister_ldisc(N_X25); 824} 825 826module_init(init_x25_asy); 827module_exit(exit_x25_asy); 828