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