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