drivers/net/hamradio/mkiss.c

   1 /*
   2  *      MKISS Driver
   3  *
   4  *      This module:
   5  *              This module is free software; you can redistribute it and/or
   6  *              modify it under the terms of the GNU General Public License
   7  *              as published by the Free Software Foundation; either version
   8  *              2 of the License, or (at your option) any later version.
   9  *
  10  *              This module implements the AX.25 protocol for kernel-based
  11  *              devices like TTYs. It interfaces between a raw TTY, and the
  12  *              kernel's AX.25 protocol layers, just like slip.c.
  13  *              AX.25 needs to be separated from slip.c while slip.c is no
  14  *              longer a static kernel device since it is a module.
  15  *              This method clears the way to implement other kiss protocols
  16  *              like mkiss smack g8bpq ..... so far only mkiss is implemented.
  17  *
  18  * Hans Alblas <hans@esrac.ele.tue.nl>
  19  *
  20  *      History
  21  *      Jonathan (G4KLX)        Fixed to match Linux networking changes - 2.1.15.
  22  *      Matthias (DG2FEF)       Added support for FlexNet CRC (on special request)
  23  *                              Fixed bug in ax25_close(): dev_lock_wait() was
  24  *                              called twice, causing a deadlock.
  25  *      Jeroen (PE1RXQ)         Removed old MKISS_MAGIC stuff and calls to
  26  *                              MOD_*_USE_COUNT
  27  *                              Remove cli() and fix rtnl lock usage.
  28  */
  29
  30 #include <linux/config.h>
  31 #include <linux/module.h>
  32 #include <asm/system.h>
  33 #include <linux/bitops.h>
  34 #include <asm/uaccess.h>
  35 #include <linux/string.h>
  36 #include <linux/mm.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/in.h>
  39 #include <linux/inet.h>
  40 #include <linux/tty.h>
  41 #include <linux/errno.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/major.h>
  44 #include <linux/init.h>
  45 #include <linux/rtnetlink.h>
  46 #include <linux/etherdevice.h>
  47 #include <linux/skbuff.h>
  48 #include <linux/if_arp.h>
  49
  50 #include <net/ax25.h>
  51
  52 #include "mkiss.h"
  53
  54 #ifdef CONFIG_INET
  55 #include <linux/ip.h>
  56 #include <linux/tcp.h>
  57 #endif
  58
  59 static char banner[] __initdata = KERN_INFO "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
  60
  61 typedef struct ax25_ctrl {
  62         struct ax_disp ctrl;    /*                              */
  63         struct net_device  dev; /* the device                   */
  64 } ax25_ctrl_t;
  65
  66 static ax25_ctrl_t **ax25_ctrls;
  67
  68 int ax25_maxdev = AX25_MAXDEV;          /* Can be overridden with insmod! */
  69
  70 static struct tty_ldisc ax_ldisc;
  71
  72 static int ax25_init(struct net_device *);
  73 static int kiss_esc(unsigned char *, unsigned char *, int);
  74 static int kiss_esc_crc(unsigned char *, unsigned char *, unsigned short, int);
  75 static void kiss_unesc(struct ax_disp *, unsigned char);
  76
  77 /*---------------------------------------------------------------------------*/
  78
  79 static const unsigned short Crc_flex_table[] = {
  80   0x0f87, 0x1e0e, 0x2c95, 0x3d1c, 0x49a3, 0x582a, 0x6ab1, 0x7b38,
  81   0x83cf, 0x9246, 0xa0dd, 0xb154, 0xc5eb, 0xd462, 0xe6f9, 0xf770,
  82   0x1f06, 0x0e8f, 0x3c14, 0x2d9d, 0x5922, 0x48ab, 0x7a30, 0x6bb9,
  83   0x934e, 0x82c7, 0xb05c, 0xa1d5, 0xd56a, 0xc4e3, 0xf678, 0xe7f1,
  84   0x2e85, 0x3f0c, 0x0d97, 0x1c1e, 0x68a1, 0x7928, 0x4bb3, 0x5a3a,
  85   0xa2cd, 0xb344, 0x81df, 0x9056, 0xe4e9, 0xf560, 0xc7fb, 0xd672,
  86   0x3e04, 0x2f8d, 0x1d16, 0x0c9f, 0x7820, 0x69a9, 0x5b32, 0x4abb,
  87   0xb24c, 0xa3c5, 0x915e, 0x80d7, 0xf468, 0xe5e1, 0xd77a, 0xc6f3,
  88   0x4d83, 0x5c0a, 0x6e91, 0x7f18, 0x0ba7, 0x1a2e, 0x28b5, 0x393c,
  89   0xc1cb, 0xd042, 0xe2d9, 0xf350, 0x87ef, 0x9666, 0xa4fd, 0xb574,
  90   0x5d02, 0x4c8b, 0x7e10, 0x6f99, 0x1b26, 0x0aaf, 0x3834, 0x29bd,
  91   0xd14a, 0xc0c3, 0xf258, 0xe3d1, 0x976e, 0x86e7, 0xb47c, 0xa5f5,
  92   0x6c81, 0x7d08, 0x4f93, 0x5e1a, 0x2aa5, 0x3b2c, 0x09b7, 0x183e,
  93   0xe0c9, 0xf140, 0xc3db, 0xd252, 0xa6ed, 0xb764, 0x85ff, 0x9476,
  94   0x7c00, 0x6d89, 0x5f12, 0x4e9b, 0x3a24, 0x2bad, 0x1936, 0x08bf,
  95   0xf048, 0xe1c1, 0xd35a, 0xc2d3, 0xb66c, 0xa7e5, 0x957e, 0x84f7,
  96   0x8b8f, 0x9a06, 0xa89d, 0xb914, 0xcdab, 0xdc22, 0xeeb9, 0xff30,
  97   0x07c7, 0x164e, 0x24d5, 0x355c, 0x41e3, 0x506a, 0x62f1, 0x7378,
  98   0x9b0e, 0x8a87, 0xb81c, 0xa995, 0xdd2a, 0xcca3, 0xfe38, 0xefb1,
  99   0x1746, 0x06cf, 0x3454, 0x25dd, 0x5162, 0x40eb, 0x7270, 0x63f9,
 100   0xaa8d, 0xbb04, 0x899f, 0x9816, 0xeca9, 0xfd20, 0xcfbb, 0xde32,
 101   0x26c5, 0x374c, 0x05d7, 0x145e, 0x60e1, 0x7168, 0x43f3, 0x527a,
 102   0xba0c, 0xab85, 0x991e, 0x8897, 0xfc28, 0xeda1, 0xdf3a, 0xceb3,
 103   0x3644, 0x27cd, 0x1556, 0x04df, 0x7060, 0x61e9, 0x5372, 0x42fb,
 104   0xc98b, 0xd802, 0xea99, 0xfb10, 0x8faf, 0x9e26, 0xacbd, 0xbd34,
 105   0x45c3, 0x544a, 0x66d1, 0x7758, 0x03e7, 0x126e, 0x20f5, 0x317c,
 106   0xd90a, 0xc883, 0xfa18, 0xeb91, 0x9f2e, 0x8ea7, 0xbc3c, 0xadb5,
 107   0x5542, 0x44cb, 0x7650, 0x67d9, 0x1366, 0x02ef, 0x3074, 0x21fd,
 108   0xe889, 0xf900, 0xcb9b, 0xda12, 0xaead, 0xbf24, 0x8dbf, 0x9c36,
 109   0x64c1, 0x7548, 0x47d3, 0x565a, 0x22e5, 0x336c, 0x01f7, 0x107e,
 110   0xf808, 0xe981, 0xdb1a, 0xca93, 0xbe2c, 0xafa5, 0x9d3e, 0x8cb7,
 111   0x7440, 0x65c9, 0x5752, 0x46db, 0x3264, 0x23ed, 0x1176, 0x00ff
 112 };
 113
 114 /*---------------------------------------------------------------------------*/
 115
 116 static unsigned short calc_crc_flex(unsigned char *cp, int size)
 117 {
 118     unsigned short crc = 0xffff;
 119
 120     while (size--)
 121         crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
 122
 123     return crc;
 124 }
 125
 126 /*---------------------------------------------------------------------------*/
 127
 128 static int check_crc_flex(unsigned char *cp, int size)
 129 {
 130   unsigned short crc = 0xffff;
 131
 132   if (size < 3)
 133       return -1;
 134
 135   while (size--)
 136       crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
 137
 138   if ((crc & 0xffff) != 0x7070)
 139       return -1;
 140
 141   return 0;
 142 }
 143
 144 /*---------------------------------------------------------------------------*/
 145
 146 /* Find a free channel, and link in this `tty' line. */
 147 static inline struct ax_disp *ax_alloc(void)
 148 {
 149         ax25_ctrl_t *axp=NULL;
 150         int i;
 151
 152         for (i = 0; i < ax25_maxdev; i++) {
 153                 axp = ax25_ctrls[i];
 154
 155                 /* Not allocated ? */
 156                 if (axp == NULL)
 157                         break;
 158
 159                 /* Not in use ? */
 160                 if (!test_and_set_bit(AXF_INUSE, &axp->ctrl.flags))
 161                         break;
 162         }
 163
 164         /* Sorry, too many, all slots in use */
 165         if (i >= ax25_maxdev)
 166                 return NULL;
 167
 168         /* If no channels are available, allocate one */
 169         if (axp == NULL && (ax25_ctrls[i] = kmalloc(sizeof(ax25_ctrl_t), GFP_KERNEL)) != NULL) {
 170                 axp = ax25_ctrls[i];
 171         }
 172         memset(axp, 0, sizeof(ax25_ctrl_t));
 173
 174         /* Initialize channel control data */
 175         set_bit(AXF_INUSE, &axp->ctrl.flags);
 176         sprintf(axp->dev.name, "ax%d", i++);
 177         axp->ctrl.tty      = NULL;
 178         axp->dev.base_addr = i;
 179         axp->dev.priv      = (void *)&axp->ctrl;
 180         axp->dev.next      = NULL;
 181         axp->dev.init      = ax25_init;
 182
 183         if (axp != NULL) {
 184                 /*
 185                  * register device so that it can be ifconfig'ed
 186                  * ax25_init() will be called as a side-effect
 187                  * SIDE-EFFECT WARNING: ax25_init() CLEARS axp->ctrl !
 188                  */
 189                 if (register_netdev(&axp->dev) == 0) {
 190                         /* (Re-)Set the INUSE bit.   Very Important! */
 191                         set_bit(AXF_INUSE, &axp->ctrl.flags);
 192                         axp->ctrl.dev = &axp->dev;
 193                         axp->dev.priv = (void *) &axp->ctrl;
 194
 195                         return &axp->ctrl;
 196                 } else {
 197                         clear_bit(AXF_INUSE,&axp->ctrl.flags);
 198                         printk(KERN_ERR "mkiss: ax_alloc() - register_netdev() failure.\n");
 199                 }
 200         }
 201
 202         return NULL;
 203 }
 204
 205 /* Free an AX25 channel. */
 206 static inline void ax_free(struct ax_disp *ax)
 207 {
 208         /* Free all AX25 frame buffers. */
 209         if (ax->rbuff)
 210                 kfree(ax->rbuff);
 211         ax->rbuff = NULL;
 212         if (ax->xbuff)
 213                 kfree(ax->xbuff);
 214         ax->xbuff = NULL;
 215         if (!test_and_clear_bit(AXF_INUSE, &ax->flags))
 216                 printk(KERN_ERR "mkiss: %s: ax_free for already free unit.\n", ax->dev->name);
 217 }
 218
 219 static void ax_changedmtu(struct ax_disp *ax)
 220 {
 221         struct net_device *dev = ax->dev;
 222         unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
 223         int len;
 224
 225         len = dev->mtu * 2;
 226
 227         /*
 228          * allow for arrival of larger UDP packets, even if we say not to
 229          * also fixes a bug in which SunOS sends 512-byte packets even with
 230          * an MSS of 128
 231          */
 232         if (len < 576 * 2)
 233                 len = 576 * 2;
 234
 235         xbuff = kmalloc(len + 4, GFP_ATOMIC);
 236         rbuff = kmalloc(len + 4, GFP_ATOMIC);
 237
 238         if (xbuff == NULL || rbuff == NULL)  {
 239                 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, MTU change cancelled.\n",
 240                        ax->dev->name);
 241                 dev->mtu = ax->mtu;
 242                 if (xbuff != NULL)
 243                         kfree(xbuff);
 244                 if (rbuff != NULL)
 245                         kfree(rbuff);
 246                 return;
 247         }
 248
 249         spin_lock_bh(&ax->buflock);
 250
 251         oxbuff    = ax->xbuff;
 252         ax->xbuff = xbuff;
 253         orbuff    = ax->rbuff;
 254         ax->rbuff = rbuff;
 255
 256         if (ax->xleft) {
 257                 if (ax->xleft <= len) {
 258                         memcpy(ax->xbuff, ax->xhead, ax->xleft);
 259                 } else  {
 260                         ax->xleft = 0;
 261                         ax->tx_dropped++;
 262                 }
 263         }
 264
 265         ax->xhead = ax->xbuff;
 266
 267         if (ax->rcount) {
 268                 if (ax->rcount <= len) {
 269                         memcpy(ax->rbuff, orbuff, ax->rcount);
 270                 } else  {
 271                         ax->rcount = 0;
 272                         ax->rx_over_errors++;
 273                         set_bit(AXF_ERROR, &ax->flags);
 274                 }
 275         }
 276
 277         ax->mtu      = dev->mtu + 73;
 278         ax->buffsize = len;
 279
 280         spin_unlock_bh(&ax->buflock);
 281
 282         if (oxbuff != NULL)
 283                 kfree(oxbuff);
 284         if (orbuff != NULL)
 285                 kfree(orbuff);
 286 }
 287
 288
 289 /* Set the "sending" flag.  This must be atomic. */
 290 static inline void ax_lock(struct ax_disp *ax)
 291 {
 292         netif_stop_queue(ax->dev);
 293 }
 294
 295
 296 /* Clear the "sending" flag.  This must be atomic. */
 297 static inline void ax_unlock(struct ax_disp *ax)
 298 {
 299         netif_start_queue(ax->dev);
 300 }
 301
 302 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
 303 static void ax_bump(struct ax_disp *ax)
 304 {
 305         struct sk_buff *skb;
 306         int count;
 307
 308         spin_lock_bh(&ax->buflock);
 309         if (ax->rbuff[0] > 0x0f) {
 310                 if (ax->rbuff[0] & 0x20) {
 311                         ax->crcmode = CRC_MODE_FLEX;
 312                         if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
 313                                 ax->rx_errors++;
 314                                 return;
 315                         }
 316                         ax->rcount -= 2;
 317                         /* dl9sau bugfix: the trailling two bytes flexnet crc
 318                          * will not be passed to the kernel. thus we have
 319                          * to correct the kissparm signature, because it
 320                          * indicates a crc but there's none
 321                          */
 322                         *ax->rbuff &= ~0x20;
 323                 }
 324         }
 325         spin_unlock_bh(&ax->buflock);
 326
 327         count = ax->rcount;
 328
 329         if ((skb = dev_alloc_skb(count)) == NULL) {
 330                 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n", ax->dev->name);
 331                 ax->rx_dropped++;
 332                 return;
 333         }
 334
 335         spin_lock_bh(&ax->buflock);
 336         memcpy(skb_put(skb,count), ax->rbuff, count);
 337         spin_unlock_bh(&ax->buflock);
 338         skb->protocol = ax25_type_trans(skb, ax->dev);
 339         netif_rx(skb);
 340         ax->dev->last_rx = jiffies;
 341         ax->rx_packets++;
 342         ax->rx_bytes+=count;
 343 }
 344
 345 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
 346 static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
 347 {
 348         unsigned char *p;
 349         int actual, count;
 350
 351         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
 352                 ax_changedmtu(ax);
 353
 354         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
 355                 len = ax->mtu;
 356                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
 357                 ax->tx_dropped++;
 358                 ax_unlock(ax);
 359                 return;
 360         }
 361
 362         p = icp;
 363
 364         spin_lock_bh(&ax->buflock);
 365         switch (ax->crcmode) {
 366                  unsigned short crc;
 367
 368         case CRC_MODE_FLEX:
 369                  *p |= 0x20;
 370                  crc = calc_crc_flex(p, len);
 371                  count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
 372                  break;
 373
 374         default:
 375                  count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
 376                  break;
 377         }
 378
 379         ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
 380         actual = ax->tty->driver->write(ax->tty, ax->xbuff, count);
 381         ax->tx_packets++;
 382         ax->tx_bytes+=actual;
 383         ax->dev->trans_start = jiffies;
 384         ax->xleft = count - actual;
 385         ax->xhead = ax->xbuff + actual;
 386
 387         spin_unlock_bh(&ax->buflock);
 388 }
 389
 390 /*
 391  * Called by the driver when there's room for more data.  If we have
 392  * more packets to send, we send them here.
 393  */
 394 static void ax25_write_wakeup(struct tty_struct *tty)
 395 {
 396         int actual;
 397         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 398
 399         /* First make sure we're connected. */
 400         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
 401                 return;
 402         if (ax->xleft <= 0)  {
 403                 /* Now serial buffer is almost free & we can start
 404                  * transmission of another packet
 405                  */
 406                 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 407
 408                 netif_wake_queue(ax->dev);
 409                 return;
 410         }
 411
 412         actual = tty->driver->write(tty, ax->xhead, ax->xleft);
 413         ax->xleft -= actual;
 414         ax->xhead += actual;
 415 }
 416
 417 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
 418 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
 419 {
 420         struct ax_disp *ax = netdev_priv(dev);
 421
 422         if (!netif_running(dev))  {
 423                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
 424                 return 1;
 425         }
 426
 427         if (netif_queue_stopped(dev)) {
 428                 /*
 429                  * May be we must check transmitter timeout here ?
 430                  *      14 Oct 1994 Dmitry Gorodchanin.
 431                  */
 432                 if (jiffies - dev->trans_start  < 20 * HZ) {
 433                         /* 20 sec timeout not reached */
 434                         return 1;
 435                 }
 436
 437                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
 438                        (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
 439                        "bad line quality" : "driver error");
 440
 441                 ax->xleft = 0;
 442                 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 443                 ax_unlock(ax);
 444         }
 445
 446         /* We were not busy, so we are now... :-) */
 447         if (skb != NULL) {
 448                 ax_lock(ax);
 449                 ax_encaps(ax, skb->data, skb->len);
 450                 kfree_skb(skb);
 451         }
 452
 453         return 0;
 454 }
 455
 456 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 457
 458 /* Return the frame type ID */
 459 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
 460           void *daddr, void *saddr, unsigned len)
 461 {
 462 #ifdef CONFIG_INET
 463         if (type != htons(ETH_P_AX25))
 464                 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
 465 #endif
 466         return 0;
 467 }
 468
 469
 470 static int ax_rebuild_header(struct sk_buff *skb)
 471 {
 472 #ifdef CONFIG_INET
 473         return ax25_rebuild_header(skb);
 474 #else
 475         return 0;
 476 #endif
 477 }
 478
 479 #endif  /* CONFIG_{AX25,AX25_MODULE} */
 480
 481 /* Open the low-level part of the AX25 channel. Easy! */
 482 static int ax_open(struct net_device *dev)
 483 {
 484         struct ax_disp *ax = netdev_priv(dev);
 485         unsigned long len;
 486
 487         if (ax->tty == NULL)
 488                 return -ENODEV;
 489
 490         /*
 491          * Allocate the frame buffers:
 492          *
 493          * rbuff        Receive buffer.
 494          * xbuff        Transmit buffer.
 495          */
 496         len = dev->mtu * 2;
 497
 498         /*
 499          * allow for arrival of larger UDP packets, even if we say not to
 500          * also fixes a bug in which SunOS sends 512-byte packets even with
 501          * an MSS of 128
 502          */
 503         if (len < 576 * 2)
 504                 len = 576 * 2;
 505
 506         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 507                 goto norbuff;
 508
 509         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 510                 goto noxbuff;
 511
 512         ax->mtu      = dev->mtu + 73;
 513         ax->buffsize = len;
 514         ax->rcount   = 0;
 515         ax->xleft    = 0;
 516
 517         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
 518
 519         spin_lock_init(&ax->buflock);
 520
 521         netif_start_queue(dev);
 522         return 0;
 523
 524 noxbuff:
 525         kfree(ax->rbuff);
 526
 527 norbuff:
 528         return -ENOMEM;
 529 }
 530
 531
 532 /* Close the low-level part of the AX25 channel. Easy! */
 533 static int ax_close(struct net_device *dev)
 534 {
 535         struct ax_disp *ax = netdev_priv(dev);
 536
 537         if (ax->tty == NULL)
 538                 return -EBUSY;
 539
 540         ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 541
 542         netif_stop_queue(dev);
 543
 544         return 0;
 545 }
 546
 547 static int ax25_receive_room(struct tty_struct *tty)
 548 {
 549         return 65536;  /* We can handle an infinite amount of data. :-) */
 550 }
 551
 552 /*
 553  * Handle the 'receiver data ready' interrupt.
 554  * This function is called by the 'tty_io' module in the kernel when
 555  * a block of data has been received, which can now be decapsulated
 556  * and sent on to the AX.25 layer for further processing.
 557  */
 558 static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
 559 {
 560         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 561
 562         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
 563                 return;
 564
 565         /*
 566          * Argh! mtu change time! - costs us the packet part received
 567          * at the change
 568          */
 569         if (ax->mtu != ax->dev->mtu + 73)
 570                 ax_changedmtu(ax);
 571
 572         /* Read the characters out of the buffer */
 573         while (count--) {
 574                 if (fp != NULL && *fp++) {
 575                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
 576                                 ax->rx_errors++;
 577                         cp++;
 578                         continue;
 579                 }
 580
 581                 kiss_unesc(ax, *cp++);
 582         }
 583 }
 584
 585 static int ax25_open(struct tty_struct *tty)
 586 {
 587         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 588         int err;
 589
 590         /* First make sure we're not already connected. */
 591         if (ax && ax->magic == AX25_MAGIC)
 592                 return -EEXIST;
 593
 594         /* OK.  Find a free AX25 channel to use. */
 595         if ((ax = ax_alloc()) == NULL)
 596                 return -ENFILE;
 597
 598         ax->tty = tty;
 599         tty->disc_data = ax;
 600
 601         if (tty->driver->flush_buffer)
 602                 tty->driver->flush_buffer(tty);
 603
 604         /* Restore default settings */
 605         ax->dev->type = ARPHRD_AX25;
 606
 607         /* Perform the low-level AX25 initialization. */
 608         if ((err = ax_open(ax->dev)))
 609                 return err;
 610
 611         /* Done.  We have linked the TTY line to a channel. */
 612         return ax->dev->base_addr;
 613 }
 614
 615 static void ax25_close(struct tty_struct *tty)
 616 {
 617         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 618
 619         /* First make sure we're connected. */
 620         if (ax == NULL || ax->magic != AX25_MAGIC)
 621                 return;
 622
 623         unregister_netdev(ax->dev);
 624
 625         tty->disc_data = NULL;
 626         ax->tty        = NULL;
 627
 628         ax_free(ax);
 629 }
 630
 631
 632 static struct net_device_stats *ax_get_stats(struct net_device *dev)
 633 {
 634         static struct net_device_stats stats;
 635         struct ax_disp *ax = netdev_priv(dev);
 636
 637         memset(&stats, 0, sizeof(struct net_device_stats));
 638
 639         stats.rx_packets     = ax->rx_packets;
 640         stats.tx_packets     = ax->tx_packets;
 641         stats.rx_bytes       = ax->rx_bytes;
 642         stats.tx_bytes       = ax->tx_bytes;
 643         stats.rx_dropped     = ax->rx_dropped;
 644         stats.tx_dropped     = ax->tx_dropped;
 645         stats.tx_errors      = ax->tx_errors;
 646         stats.rx_errors      = ax->rx_errors;
 647         stats.rx_over_errors = ax->rx_over_errors;
 648
 649         return &stats;
 650 }
 651
 652
 653 /************************************************************************
 654  *                         STANDARD ENCAPSULATION                        *
 655  ************************************************************************/
 656
 657 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
 658 {
 659         unsigned char *ptr = d;
 660         unsigned char c;
 661
 662         /*
 663          * Send an initial END character to flush out any
 664          * data that may have accumulated in the receiver
 665          * due to line noise.
 666          */
 667
 668         *ptr++ = END;
 669
 670         while (len-- > 0) {
 671                 switch (c = *s++) {
 672                         case END:
 673                                 *ptr++ = ESC;
 674                                 *ptr++ = ESC_END;
 675                                 break;
 676                         case ESC:
 677                                 *ptr++ = ESC;
 678                                 *ptr++ = ESC_ESC;
 679                                 break;
 680                         default:
 681                                 *ptr++ = c;
 682                                 break;
 683                 }
 684         }
 685
 686         *ptr++ = END;
 687
 688         return ptr - d;
 689 }
 690
 691 /*
 692  * MW:
 693  * OK its ugly, but tell me a better solution without copying the
 694  * packet to a temporary buffer :-)
 695  */
 696 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
 697 {
 698         unsigned char *ptr = d;
 699         unsigned char c=0;
 700
 701         *ptr++ = END;
 702         while (len > 0) {
 703                 if (len > 2)
 704                         c = *s++;
 705                 else if (len > 1)
 706                         c = crc >> 8;
 707                 else if (len > 0)
 708                         c = crc & 0xff;
 709
 710                 len--;
 711
 712                 switch (c) {
 713                         case END:
 714                                 *ptr++ = ESC;
 715                                 *ptr++ = ESC_END;
 716                                 break;
 717                         case ESC:
 718                                 *ptr++ = ESC;
 719                                 *ptr++ = ESC_ESC;
 720                                 break;
 721                         default:
 722                                 *ptr++ = c;
 723                                 break;
 724                 }
 725         }
 726         *ptr++ = END;
 727         return ptr - d;
 728 }
 729
 730 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
 731 {
 732         switch (s) {
 733                 case END:
 734                         /* drop keeptest bit = VSV */
 735                         if (test_bit(AXF_KEEPTEST, &ax->flags))
 736                                 clear_bit(AXF_KEEPTEST, &ax->flags);
 737
 738                         if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
 739                                 ax_bump(ax);
 740
 741                         clear_bit(AXF_ESCAPE, &ax->flags);
 742                         ax->rcount = 0;
 743                         return;
 744
 745                 case ESC:
 746                         set_bit(AXF_ESCAPE, &ax->flags);
 747                         return;
 748                 case ESC_ESC:
 749                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 750                                 s = ESC;
 751                         break;
 752                 case ESC_END:
 753                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 754                                 s = END;
 755                         break;
 756         }
 757
 758         spin_lock_bh(&ax->buflock);
 759         if (!test_bit(AXF_ERROR, &ax->flags)) {
 760                 if (ax->rcount < ax->buffsize) {
 761                         ax->rbuff[ax->rcount++] = s;
 762                         spin_unlock_bh(&ax->buflock);
 763                         return;
 764                 }
 765
 766                 ax->rx_over_errors++;
 767                 set_bit(AXF_ERROR, &ax->flags);
 768         }
 769         spin_unlock_bh(&ax->buflock);
 770 }
 771
 772
 773 static int ax_set_mac_address(struct net_device *dev, void __user *addr)
 774 {
 775         if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
 776                 return -EFAULT;
 777         return 0;
 778 }
 779
 780 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
 781 {
 782         struct sockaddr *sa = addr;
 783
 784         memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
 785
 786         return 0;
 787 }
 788
 789
 790 /* Perform I/O control on an active ax25 channel. */
 791 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void __user *arg)
 792 {
 793         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 794         unsigned int tmp;
 795
 796         /* First make sure we're connected. */
 797         if (ax == NULL || ax->magic != AX25_MAGIC)
 798                 return -EINVAL;
 799
 800         switch (cmd) {
 801                 case SIOCGIFNAME:
 802                         if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
 803                                 return -EFAULT;
 804                         return 0;
 805
 806                 case SIOCGIFENCAP:
 807                         return put_user(4, (int __user *)arg);
 808
 809                 case SIOCSIFENCAP:
 810                         if (get_user(tmp, (int __user *)arg))
 811                                 return -EFAULT;
 812                         ax->mode = tmp;
 813                         ax->dev->addr_len        = AX25_ADDR_LEN;         /* sizeof an AX.25 addr */
 814                         ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
 815                         ax->dev->type            = ARPHRD_AX25;
 816                         return 0;
 817
 818                  case SIOCSIFHWADDR:
 819                         return ax_set_mac_address(ax->dev, arg);
 820
 821                 default:
 822                         return -ENOIOCTLCMD;
 823         }
 824 }
 825
 826 static int ax_open_dev(struct net_device *dev)
 827 {
 828         struct ax_disp *ax = netdev_priv(dev);
 829
 830         if (ax->tty == NULL)
 831                 return -ENODEV;
 832
 833         return 0;
 834 }
 835
 836
 837 /* Initialize the driver.  Called by network startup. */
 838 static int ax25_init(struct net_device *dev)
 839 {
 840         struct ax_disp *ax = netdev_priv(dev);
 841
 842         static char ax25_bcast[AX25_ADDR_LEN] =
 843                 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
 844         static char ax25_test[AX25_ADDR_LEN] =
 845                 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
 846
 847         if (ax == NULL)         /* Allocation failed ?? */
 848                 return -ENODEV;
 849
 850         /* Set up the "AX25 Control Block". (And clear statistics) */
 851         memset(ax, 0, sizeof (struct ax_disp));
 852         ax->magic  = AX25_MAGIC;
 853         ax->dev    = dev;
 854
 855         /* Finish setting up the DEVICE info. */
 856         dev->mtu             = AX_MTU;
 857         dev->hard_start_xmit = ax_xmit;
 858         dev->open            = ax_open_dev;
 859         dev->stop            = ax_close;
 860         dev->get_stats       = ax_get_stats;
 861         dev->set_mac_address = ax_set_dev_mac_address;
 862         dev->hard_header_len = 0;
 863         dev->addr_len        = 0;
 864         dev->type            = ARPHRD_AX25;
 865         dev->tx_queue_len    = 10;
 866         dev->hard_header     = ax_header;
 867         dev->rebuild_header  = ax_rebuild_header;
 868
 869         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
 870         memcpy(dev->dev_addr,  ax25_test,  AX25_ADDR_LEN);
 871
 872         /* New-style flags. */
 873         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
 874
 875         return 0;
 876 }
 877
 878
 879 /* ******************************************************************** */
 880 /* *                    Init MKISS driver                             * */
 881 /* ******************************************************************** */
 882
 883 static int __init mkiss_init_driver(void)
 884 {
 885         int status;
 886
 887         printk(banner);
 888
 889         if (ax25_maxdev < 4)
 890           ax25_maxdev = 4; /* Sanity */
 891
 892         if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
 893                 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
 894                 return -ENOMEM;
 895         }
 896
 897         /* Clear the pointer array, we allocate devices when we need them */
 898         memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
 899
 900         /* Fill in our line protocol discipline, and register it */
 901         ax_ldisc.magic          = TTY_LDISC_MAGIC;
 902         ax_ldisc.name           = "mkiss";
 903         ax_ldisc.open           = ax25_open;
 904         ax_ldisc.close          = ax25_close;
 905         ax_ldisc.ioctl          = (int (*)(struct tty_struct *, struct file *,
 906                                         unsigned int, unsigned long))ax25_disp_ioctl;
 907         ax_ldisc.receive_buf    = ax25_receive_buf;
 908         ax_ldisc.receive_room   = ax25_receive_room;
 909         ax_ldisc.write_wakeup   = ax25_write_wakeup;
 910
 911         if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
 912                 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
 913                 kfree(ax25_ctrls);
 914         }
 915         return status;
 916 }
 917
 918 static void __exit mkiss_exit_driver(void)
 919 {
 920         int i;
 921
 922         for (i = 0; i < ax25_maxdev; i++) {
 923                 if (ax25_ctrls[i]) {
 924                         /*
 925                         * VSV = if dev->start==0, then device
 926                         * unregistered while close proc.
 927                         */
 928                         if (netif_running(&ax25_ctrls[i]->dev))
 929                                 unregister_netdev(&ax25_ctrls[i]->dev);
 930                         kfree(ax25_ctrls[i]);
 931                 }
 932         }
 933
 934         kfree(ax25_ctrls);
 935         ax25_ctrls = NULL;
 936
 937         if ((i = tty_unregister_ldisc(N_AX25)))
 938                 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
 939 }
 940
 941 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
 942 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
 943 MODULE_PARM(ax25_maxdev, "i");
 944 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
 945 MODULE_LICENSE("GPL");
 946 MODULE_ALIAS_LDISC(N_AX25);
 947 module_init(mkiss_init_driver);
 948 module_exit(mkiss_exit_driver);
 949