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 <asm/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         skb->dev      = ax->dev;
 336         spin_lock_bh(&ax->buflock);
 337         memcpy(skb_put(skb,count), ax->rbuff, count);
 338         spin_unlock_bh(&ax->buflock);
 339         skb->mac.raw  = skb->data;
 340         skb->protocol = htons(ETH_P_AX25);
 341         netif_rx(skb);
 342         ax->dev->last_rx = jiffies;
 343         ax->rx_packets++;
 344         ax->rx_bytes+=count;
 345 }
 346
 347 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
 348 static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
 349 {
 350         unsigned char *p;
 351         int actual, count;
 352
 353         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
 354                 ax_changedmtu(ax);
 355
 356         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
 357                 len = ax->mtu;
 358                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
 359                 ax->tx_dropped++;
 360                 ax_unlock(ax);
 361                 return;
 362         }
 363
 364         p = icp;
 365
 366         spin_lock_bh(&ax->buflock);
 367         switch (ax->crcmode) {
 368                  unsigned short crc;
 369
 370         case CRC_MODE_FLEX:
 371                  *p |= 0x20;
 372                  crc = calc_crc_flex(p, len);
 373                  count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
 374                  break;
 375
 376         default:
 377                  count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
 378                  break;
 379         }
 380
 381         ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
 382         actual = ax->tty->driver->write(ax->tty, 0, ax->xbuff, count);
 383         ax->tx_packets++;
 384         ax->tx_bytes+=actual;
 385         ax->dev->trans_start = jiffies;
 386         ax->xleft = count - actual;
 387         ax->xhead = ax->xbuff + actual;
 388
 389         spin_unlock_bh(&ax->buflock);
 390 }
 391
 392 /*
 393  * Called by the driver when there's room for more data.  If we have
 394  * more packets to send, we send them here.
 395  */
 396 static void ax25_write_wakeup(struct tty_struct *tty)
 397 {
 398         int actual;
 399         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 400
 401         /* First make sure we're connected. */
 402         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
 403                 return;
 404         if (ax->xleft <= 0)  {
 405                 /* Now serial buffer is almost free & we can start
 406                  * transmission of another packet
 407                  */
 408                 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 409
 410                 netif_wake_queue(ax->dev);
 411                 return;
 412         }
 413
 414         actual = tty->driver->write(tty, 0, ax->xhead, ax->xleft);
 415         ax->xleft -= actual;
 416         ax->xhead += actual;
 417 }
 418
 419 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
 420 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
 421 {
 422         struct ax_disp *ax = (struct ax_disp *) dev->priv;
 423
 424         if (!netif_running(dev))  {
 425                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
 426                 return 1;
 427         }
 428
 429         if (netif_queue_stopped(dev)) {
 430                 /*
 431                  * May be we must check transmitter timeout here ?
 432                  *      14 Oct 1994 Dmitry Gorodchanin.
 433                  */
 434                 if (jiffies - dev->trans_start  < 20 * HZ) {
 435                         /* 20 sec timeout not reached */
 436                         return 1;
 437                 }
 438
 439                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
 440                        (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
 441                        "bad line quality" : "driver error");
 442
 443                 ax->xleft = 0;
 444                 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 445                 ax_unlock(ax);
 446         }
 447
 448         /* We were not busy, so we are now... :-) */
 449         if (skb != NULL) {
 450                 ax_lock(ax);
 451                 ax_encaps(ax, skb->data, skb->len);
 452                 kfree_skb(skb);
 453         }
 454
 455         return 0;
 456 }
 457
 458 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 459
 460 /* Return the frame type ID */
 461 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
 462           void *daddr, void *saddr, unsigned len)
 463 {
 464 #ifdef CONFIG_INET
 465         if (type != htons(ETH_P_AX25))
 466                 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
 467 #endif
 468         return 0;
 469 }
 470
 471
 472 static int ax_rebuild_header(struct sk_buff *skb)
 473 {
 474 #ifdef CONFIG_INET
 475         return ax25_rebuild_header(skb);
 476 #else
 477         return 0;
 478 #endif
 479 }
 480
 481 #endif  /* CONFIG_{AX25,AX25_MODULE} */
 482
 483 /* Open the low-level part of the AX25 channel. Easy! */
 484 static int ax_open(struct net_device *dev)
 485 {
 486         struct ax_disp *ax = (struct ax_disp *) dev->priv;
 487         unsigned long len;
 488
 489         if (ax->tty == NULL)
 490                 return -ENODEV;
 491
 492         /*
 493          * Allocate the frame buffers:
 494          *
 495          * rbuff        Receive buffer.
 496          * xbuff        Transmit buffer.
 497          */
 498         len = dev->mtu * 2;
 499
 500         /*
 501          * allow for arrival of larger UDP packets, even if we say not to
 502          * also fixes a bug in which SunOS sends 512-byte packets even with
 503          * an MSS of 128
 504          */
 505         if (len < 576 * 2)
 506                 len = 576 * 2;
 507
 508         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 509                 goto norbuff;
 510
 511         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 512                 goto noxbuff;
 513
 514         ax->mtu      = dev->mtu + 73;
 515         ax->buffsize = len;
 516         ax->rcount   = 0;
 517         ax->xleft    = 0;
 518
 519         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
 520
 521         ax->buflock = SPIN_LOCK_UNLOCKED;
 522
 523         netif_start_queue(dev);
 524         return 0;
 525
 526 noxbuff:
 527         kfree(ax->rbuff);
 528
 529 norbuff:
 530         return -ENOMEM;
 531 }
 532
 533
 534 /* Close the low-level part of the AX25 channel. Easy! */
 535 static int ax_close(struct net_device *dev)
 536 {
 537         struct ax_disp *ax = (struct ax_disp *) dev->priv;
 538
 539         if (ax->tty == NULL)
 540                 return -EBUSY;
 541
 542         ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 543
 544         netif_stop_queue(dev);
 545
 546         return 0;
 547 }
 548
 549 static int ax25_receive_room(struct tty_struct *tty)
 550 {
 551         return 65536;  /* We can handle an infinite amount of data. :-) */
 552 }
 553
 554 /*
 555  * Handle the 'receiver data ready' interrupt.
 556  * This function is called by the 'tty_io' module in the kernel when
 557  * a block of data has been received, which can now be decapsulated
 558  * and sent on to the AX.25 layer for further processing.
 559  */
 560 static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
 561 {
 562         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 563
 564         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
 565                 return;
 566
 567         /*
 568          * Argh! mtu change time! - costs us the packet part received
 569          * at the change
 570          */
 571         if (ax->mtu != ax->dev->mtu + 73)
 572                 ax_changedmtu(ax);
 573
 574         /* Read the characters out of the buffer */
 575         while (count--) {
 576                 if (fp != NULL && *fp++) {
 577                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
 578                                 ax->rx_errors++;
 579                         cp++;
 580                         continue;
 581                 }
 582
 583                 kiss_unesc(ax, *cp++);
 584         }
 585 }
 586
 587 static int ax25_open(struct tty_struct *tty)
 588 {
 589         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 590         int err;
 591
 592         /* First make sure we're not already connected. */
 593         if (ax && ax->magic == AX25_MAGIC)
 594                 return -EEXIST;
 595
 596         /* OK.  Find a free AX25 channel to use. */
 597         if ((ax = ax_alloc()) == NULL)
 598                 return -ENFILE;
 599
 600         ax->tty = tty;
 601         tty->disc_data = ax;
 602
 603         if (tty->driver->flush_buffer)
 604                 tty->driver->flush_buffer(tty);
 605         if (tty->ldisc.flush_buffer)
 606                 tty->ldisc.flush_buffer(tty);
 607
 608         /* Restore default settings */
 609         ax->dev->type = ARPHRD_AX25;
 610
 611         /* Perform the low-level AX25 initialization. */
 612         if ((err = ax_open(ax->dev)))
 613                 return err;
 614
 615         /* Done.  We have linked the TTY line to a channel. */
 616         return ax->dev->base_addr;
 617 }
 618
 619 static void ax25_close(struct tty_struct *tty)
 620 {
 621         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 622
 623         /* First make sure we're connected. */
 624         if (ax == NULL || ax->magic != AX25_MAGIC)
 625                 return;
 626
 627         unregister_netdev(ax->dev);
 628
 629         tty->disc_data = NULL;
 630         ax->tty        = NULL;
 631
 632         ax_free(ax);
 633 }
 634
 635
 636 static struct net_device_stats *ax_get_stats(struct net_device *dev)
 637 {
 638         static struct net_device_stats stats;
 639         struct ax_disp *ax = (struct ax_disp *) dev->priv;
 640
 641         memset(&stats, 0, sizeof(struct net_device_stats));
 642
 643         stats.rx_packets     = ax->rx_packets;
 644         stats.tx_packets     = ax->tx_packets;
 645         stats.rx_bytes       = ax->rx_bytes;
 646         stats.tx_bytes       = ax->tx_bytes;
 647         stats.rx_dropped     = ax->rx_dropped;
 648         stats.tx_dropped     = ax->tx_dropped;
 649         stats.tx_errors      = ax->tx_errors;
 650         stats.rx_errors      = ax->rx_errors;
 651         stats.rx_over_errors = ax->rx_over_errors;
 652
 653         return &stats;
 654 }
 655
 656
 657 /************************************************************************
 658  *                         STANDARD ENCAPSULATION                        *
 659  ************************************************************************/
 660
 661 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
 662 {
 663         unsigned char *ptr = d;
 664         unsigned char c;
 665
 666         /*
 667          * Send an initial END character to flush out any
 668          * data that may have accumulated in the receiver
 669          * due to line noise.
 670          */
 671
 672         *ptr++ = END;
 673
 674         while (len-- > 0) {
 675                 switch (c = *s++) {
 676                         case END:
 677                                 *ptr++ = ESC;
 678                                 *ptr++ = ESC_END;
 679                                 break;
 680                         case ESC:
 681                                 *ptr++ = ESC;
 682                                 *ptr++ = ESC_ESC;
 683                                 break;
 684                         default:
 685                                 *ptr++ = c;
 686                                 break;
 687                 }
 688         }
 689
 690         *ptr++ = END;
 691
 692         return ptr - d;
 693 }
 694
 695 /*
 696  * MW:
 697  * OK its ugly, but tell me a better solution without copying the
 698  * packet to a temporary buffer :-)
 699  */
 700 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
 701 {
 702         unsigned char *ptr = d;
 703         unsigned char c=0;
 704
 705         *ptr++ = END;
 706         while (len > 0) {
 707                 if (len > 2)
 708                         c = *s++;
 709                 else if (len > 1)
 710                         c = crc >> 8;
 711                 else if (len > 0)
 712                         c = crc & 0xff;
 713
 714                 len--;
 715
 716                 switch (c) {
 717                         case END:
 718                                 *ptr++ = ESC;
 719                                 *ptr++ = ESC_END;
 720                                 break;
 721                         case ESC:
 722                                 *ptr++ = ESC;
 723                                 *ptr++ = ESC_ESC;
 724                                 break;
 725                         default:
 726                                 *ptr++ = c;
 727                                 break;
 728                 }
 729         }
 730         *ptr++ = END;
 731         return ptr - d;
 732 }
 733
 734 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
 735 {
 736         switch (s) {
 737                 case END:
 738                         /* drop keeptest bit = VSV */
 739                         if (test_bit(AXF_KEEPTEST, &ax->flags))
 740                                 clear_bit(AXF_KEEPTEST, &ax->flags);
 741
 742                         if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
 743                                 ax_bump(ax);
 744
 745                         clear_bit(AXF_ESCAPE, &ax->flags);
 746                         ax->rcount = 0;
 747                         return;
 748
 749                 case ESC:
 750                         set_bit(AXF_ESCAPE, &ax->flags);
 751                         return;
 752                 case ESC_ESC:
 753                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 754                                 s = ESC;
 755                         break;
 756                 case ESC_END:
 757                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 758                                 s = END;
 759                         break;
 760         }
 761
 762         spin_lock_bh(&ax->buflock);
 763         if (!test_bit(AXF_ERROR, &ax->flags)) {
 764                 if (ax->rcount < ax->buffsize) {
 765                         ax->rbuff[ax->rcount++] = s;
 766                         spin_unlock_bh(&ax->buflock);
 767                         return;
 768                 }
 769
 770                 ax->rx_over_errors++;
 771                 set_bit(AXF_ERROR, &ax->flags);
 772         }
 773         spin_unlock_bh(&ax->buflock);
 774 }
 775
 776
 777 static int ax_set_mac_address(struct net_device *dev, void __user *addr)
 778 {
 779         if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
 780                 return -EFAULT;
 781         return 0;
 782 }
 783
 784 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
 785 {
 786         struct sockaddr *sa = addr;
 787
 788         memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
 789
 790         return 0;
 791 }
 792
 793
 794 /* Perform I/O control on an active ax25 channel. */
 795 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void __user *arg)
 796 {
 797         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
 798         unsigned int tmp;
 799
 800         /* First make sure we're connected. */
 801         if (ax == NULL || ax->magic != AX25_MAGIC)
 802                 return -EINVAL;
 803
 804         switch (cmd) {
 805                 case SIOCGIFNAME:
 806                         if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
 807                                 return -EFAULT;
 808                         return 0;
 809
 810                 case SIOCGIFENCAP:
 811                         return put_user(4, (int __user *)arg);
 812
 813                 case SIOCSIFENCAP:
 814                         if (get_user(tmp, (int __user *)arg))
 815                                 return -EFAULT;
 816                         ax->mode = tmp;
 817                         ax->dev->addr_len        = AX25_ADDR_LEN;         /* sizeof an AX.25 addr */
 818                         ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
 819                         ax->dev->type            = ARPHRD_AX25;
 820                         return 0;
 821
 822                  case SIOCSIFHWADDR:
 823                         return ax_set_mac_address(ax->dev, arg);
 824
 825                 default:
 826                         return -ENOIOCTLCMD;
 827         }
 828 }
 829
 830 static int ax_open_dev(struct net_device *dev)
 831 {
 832         struct ax_disp *ax = (struct ax_disp *) dev->priv;
 833
 834         if (ax->tty == NULL)
 835                 return -ENODEV;
 836
 837         return 0;
 838 }
 839
 840
 841 /* Initialize the driver.  Called by network startup. */
 842 static int ax25_init(struct net_device *dev)
 843 {
 844         struct ax_disp *ax = (struct ax_disp *) dev->priv;
 845
 846         static char ax25_bcast[AX25_ADDR_LEN] =
 847                 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
 848         static char ax25_test[AX25_ADDR_LEN] =
 849                 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
 850
 851         if (ax == NULL)         /* Allocation failed ?? */
 852                 return -ENODEV;
 853
 854         /* Set up the "AX25 Control Block". (And clear statistics) */
 855         memset(ax, 0, sizeof (struct ax_disp));
 856         ax->magic  = AX25_MAGIC;
 857         ax->dev    = dev;
 858
 859         /* Finish setting up the DEVICE info. */
 860         dev->mtu             = AX_MTU;
 861         dev->hard_start_xmit = ax_xmit;
 862         dev->open            = ax_open_dev;
 863         dev->stop            = ax_close;
 864         dev->get_stats       = ax_get_stats;
 865         dev->set_mac_address = ax_set_dev_mac_address;
 866         dev->hard_header_len = 0;
 867         dev->addr_len        = 0;
 868         dev->type            = ARPHRD_AX25;
 869         dev->tx_queue_len    = 10;
 870         dev->hard_header     = ax_header;
 871         dev->rebuild_header  = ax_rebuild_header;
 872
 873         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
 874         memcpy(dev->dev_addr,  ax25_test,  AX25_ADDR_LEN);
 875
 876         /* New-style flags. */
 877         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
 878
 879         return 0;
 880 }
 881
 882
 883 /* ******************************************************************** */
 884 /* *                    Init MKISS driver                             * */
 885 /* ******************************************************************** */
 886
 887 static int __init mkiss_init_driver(void)
 888 {
 889         int status;
 890
 891         printk(banner);
 892
 893         if (ax25_maxdev < 4)
 894           ax25_maxdev = 4; /* Sanity */
 895
 896         if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
 897                 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
 898                 return -ENOMEM;
 899         }
 900
 901         /* Clear the pointer array, we allocate devices when we need them */
 902         memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
 903
 904         /* Fill in our line protocol discipline, and register it */
 905         ax_ldisc.magic          = TTY_LDISC_MAGIC;
 906         ax_ldisc.name           = "mkiss";
 907         ax_ldisc.open           = ax25_open;
 908         ax_ldisc.close          = ax25_close;
 909         ax_ldisc.ioctl          = (int (*)(struct tty_struct *, struct file *,
 910                                         unsigned int, unsigned long))ax25_disp_ioctl;
 911         ax_ldisc.receive_buf    = ax25_receive_buf;
 912         ax_ldisc.receive_room   = ax25_receive_room;
 913         ax_ldisc.write_wakeup   = ax25_write_wakeup;
 914
 915         if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
 916                 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
 917                 kfree(ax25_ctrls);
 918         }
 919         return status;
 920 }
 921
 922 static void __exit mkiss_exit_driver(void)
 923 {
 924         int i;
 925
 926         for (i = 0; i < ax25_maxdev; i++) {
 927                 if (ax25_ctrls[i]) {
 928                         /*
 929                         * VSV = if dev->start==0, then device
 930                         * unregistered while close proc.
 931                         */
 932                         if (netif_running(&ax25_ctrls[i]->dev))
 933                                 unregister_netdev(&ax25_ctrls[i]->dev);
 934                         kfree(ax25_ctrls[i]);
 935                 }
 936         }
 937
 938         kfree(ax25_ctrls);
 939         ax25_ctrls = NULL;
 940
 941         if ((i = tty_register_ldisc(N_AX25, NULL)))
 942                 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
 943 }
 944
 945 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
 946 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
 947 MODULE_PARM(ax25_maxdev, "i");
 948 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
 949 MODULE_LICENSE("GPL");
 950 MODULE_ALIAS_LDISC(N_AX25);
 951 module_init(mkiss_init_driver);
 952 module_exit(mkiss_exit_driver);
 953