drivers/net/hamradio/mkiss.c

   1 /*
   2  *  This program is free software; you can distribute it and/or modify it
   3  *  under the terms of the GNU General Public License (Version 2) as
   4  *  published by the Free Software Foundation.
   5  *
   6  *  This program is distributed in the hope it will be useful, but WITHOUT
   7  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   8  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   9  *  for more details.
  10  *
  11  *  You should have received a copy of the GNU General Public License along
  12  *  with this program; if not, write to the Free Software Foundation, Inc.,
  13  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  14  *
  15  * Copyright (C) Hans Alblas PE1AYX <hans@esrac.ele.tue.nl>
  16  * Copyright (C) 2004, 05 Ralf Baechle DL5RB <ralf@linux-mips.org>
  17  * Copyright (C) 2004, 05 Thomas Osterried DL9SAU <thomas@x-berg.in-berlin.de>
  18  */
  19 #include <linux/module.h>
  20 #include <asm/system.h>
  21 #include <linux/bitops.h>
  22 #include <asm/uaccess.h>
  23 #include <linux/crc16.h>
  24 #include <linux/string.h>
  25 #include <linux/mm.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/in.h>
  28 #include <linux/inet.h>
  29 #include <linux/tty.h>
  30 #include <linux/errno.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/major.h>
  33 #include <linux/init.h>
  34 #include <linux/rtnetlink.h>
  35 #include <linux/etherdevice.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/if_arp.h>
  38 #include <linux/jiffies.h>
  39
  40 #include <net/ax25.h>
  41
  42 #define AX_MTU          236
  43
  44 /* SLIP/KISS protocol characters. */
  45 #define END             0300            /* indicates end of frame       */
  46 #define ESC             0333            /* indicates byte stuffing      */
  47 #define ESC_END         0334            /* ESC ESC_END means END 'data' */
  48 #define ESC_ESC         0335            /* ESC ESC_ESC means ESC 'data' */
  49
  50 struct mkiss {
  51         struct tty_struct       *tty;   /* ptr to TTY structure         */
  52         struct net_device       *dev;   /* easy for intr handling       */
  53
  54         /* These are pointers to the malloc()ed frame buffers. */
  55         spinlock_t              buflock;/* lock for rbuf and xbuf */
  56         unsigned char           *rbuff; /* receiver buffer              */
  57         int                     rcount; /* received chars counter       */
  58         unsigned char           *xbuff; /* transmitter buffer           */
  59         unsigned char           *xhead; /* pointer to next byte to XMIT */
  60         int                     xleft;  /* bytes left in XMIT queue     */
  61
  62         /* Detailed SLIP statistics. */
  63         int             mtu;            /* Our mtu (to spot changes!)   */
  64         int             buffsize;       /* Max buffers sizes            */
  65
  66         unsigned long   flags;          /* Flag values/ mode etc        */
  67                                         /* long req'd: used by set_bit --RR */
  68 #define AXF_INUSE       0               /* Channel in use               */
  69 #define AXF_ESCAPE      1               /* ESC received                 */
  70 #define AXF_ERROR       2               /* Parity, etc. error           */
  71 #define AXF_KEEPTEST    3               /* Keepalive test flag          */
  72 #define AXF_OUTWAIT     4               /* is outpacket was flag        */
  73
  74         int             mode;
  75         int             crcmode;        /* MW: for FlexNet, SMACK etc.  */
  76         int             crcauto;        /* CRC auto mode */
  77
  78 #define CRC_MODE_NONE           0
  79 #define CRC_MODE_FLEX           1
  80 #define CRC_MODE_SMACK          2
  81 #define CRC_MODE_FLEX_TEST      3
  82 #define CRC_MODE_SMACK_TEST     4
  83
  84         atomic_t                refcnt;
  85         struct semaphore        dead_sem;
  86 };
  87
  88 /*---------------------------------------------------------------------------*/
  89
  90 static const unsigned short crc_flex_table[] = {
  91         0x0f87, 0x1e0e, 0x2c95, 0x3d1c, 0x49a3, 0x582a, 0x6ab1, 0x7b38,
  92         0x83cf, 0x9246, 0xa0dd, 0xb154, 0xc5eb, 0xd462, 0xe6f9, 0xf770,
  93         0x1f06, 0x0e8f, 0x3c14, 0x2d9d, 0x5922, 0x48ab, 0x7a30, 0x6bb9,
  94         0x934e, 0x82c7, 0xb05c, 0xa1d5, 0xd56a, 0xc4e3, 0xf678, 0xe7f1,
  95         0x2e85, 0x3f0c, 0x0d97, 0x1c1e, 0x68a1, 0x7928, 0x4bb3, 0x5a3a,
  96         0xa2cd, 0xb344, 0x81df, 0x9056, 0xe4e9, 0xf560, 0xc7fb, 0xd672,
  97         0x3e04, 0x2f8d, 0x1d16, 0x0c9f, 0x7820, 0x69a9, 0x5b32, 0x4abb,
  98         0xb24c, 0xa3c5, 0x915e, 0x80d7, 0xf468, 0xe5e1, 0xd77a, 0xc6f3,
  99         0x4d83, 0x5c0a, 0x6e91, 0x7f18, 0x0ba7, 0x1a2e, 0x28b5, 0x393c,
 100         0xc1cb, 0xd042, 0xe2d9, 0xf350, 0x87ef, 0x9666, 0xa4fd, 0xb574,
 101         0x5d02, 0x4c8b, 0x7e10, 0x6f99, 0x1b26, 0x0aaf, 0x3834, 0x29bd,
 102         0xd14a, 0xc0c3, 0xf258, 0xe3d1, 0x976e, 0x86e7, 0xb47c, 0xa5f5,
 103         0x6c81, 0x7d08, 0x4f93, 0x5e1a, 0x2aa5, 0x3b2c, 0x09b7, 0x183e,
 104         0xe0c9, 0xf140, 0xc3db, 0xd252, 0xa6ed, 0xb764, 0x85ff, 0x9476,
 105         0x7c00, 0x6d89, 0x5f12, 0x4e9b, 0x3a24, 0x2bad, 0x1936, 0x08bf,
 106         0xf048, 0xe1c1, 0xd35a, 0xc2d3, 0xb66c, 0xa7e5, 0x957e, 0x84f7,
 107         0x8b8f, 0x9a06, 0xa89d, 0xb914, 0xcdab, 0xdc22, 0xeeb9, 0xff30,
 108         0x07c7, 0x164e, 0x24d5, 0x355c, 0x41e3, 0x506a, 0x62f1, 0x7378,
 109         0x9b0e, 0x8a87, 0xb81c, 0xa995, 0xdd2a, 0xcca3, 0xfe38, 0xefb1,
 110         0x1746, 0x06cf, 0x3454, 0x25dd, 0x5162, 0x40eb, 0x7270, 0x63f9,
 111         0xaa8d, 0xbb04, 0x899f, 0x9816, 0xeca9, 0xfd20, 0xcfbb, 0xde32,
 112         0x26c5, 0x374c, 0x05d7, 0x145e, 0x60e1, 0x7168, 0x43f3, 0x527a,
 113         0xba0c, 0xab85, 0x991e, 0x8897, 0xfc28, 0xeda1, 0xdf3a, 0xceb3,
 114         0x3644, 0x27cd, 0x1556, 0x04df, 0x7060, 0x61e9, 0x5372, 0x42fb,
 115         0xc98b, 0xd802, 0xea99, 0xfb10, 0x8faf, 0x9e26, 0xacbd, 0xbd34,
 116         0x45c3, 0x544a, 0x66d1, 0x7758, 0x03e7, 0x126e, 0x20f5, 0x317c,
 117         0xd90a, 0xc883, 0xfa18, 0xeb91, 0x9f2e, 0x8ea7, 0xbc3c, 0xadb5,
 118         0x5542, 0x44cb, 0x7650, 0x67d9, 0x1366, 0x02ef, 0x3074, 0x21fd,
 119         0xe889, 0xf900, 0xcb9b, 0xda12, 0xaead, 0xbf24, 0x8dbf, 0x9c36,
 120         0x64c1, 0x7548, 0x47d3, 0x565a, 0x22e5, 0x336c, 0x01f7, 0x107e,
 121         0xf808, 0xe981, 0xdb1a, 0xca93, 0xbe2c, 0xafa5, 0x9d3e, 0x8cb7,
 122         0x7440, 0x65c9, 0x5752, 0x46db, 0x3264, 0x23ed, 0x1176, 0x00ff
 123 };
 124
 125 static unsigned short calc_crc_flex(unsigned char *cp, int size)
 126 {
 127         unsigned short crc = 0xffff;
 128
 129         while (size--)
 130                 crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
 131
 132         return crc;
 133 }
 134
 135 static int check_crc_flex(unsigned char *cp, int size)
 136 {
 137         unsigned short crc = 0xffff;
 138
 139         if (size < 3)
 140                 return -1;
 141
 142         while (size--)
 143                 crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
 144
 145         if ((crc & 0xffff) != 0x7070)
 146                 return -1;
 147
 148         return 0;
 149 }
 150
 151 static int check_crc_16(unsigned char *cp, int size)
 152 {
 153         unsigned short crc = 0x0000;
 154
 155         if (size < 3)
 156                 return -1;
 157
 158         crc = crc16(0, cp, size);
 159
 160         if (crc != 0x0000)
 161                 return -1;
 162
 163         return 0;
 164 }
 165
 166 /*
 167  * Standard encapsulation
 168  */
 169
 170 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
 171 {
 172         unsigned char *ptr = d;
 173         unsigned char c;
 174
 175         /*
 176          * Send an initial END character to flush out any data that may have
 177          * accumulated in the receiver due to line noise.
 178          */
 179
 180         *ptr++ = END;
 181
 182         while (len-- > 0) {
 183                 switch (c = *s++) {
 184                 case END:
 185                         *ptr++ = ESC;
 186                         *ptr++ = ESC_END;
 187                         break;
 188                 case ESC:
 189                         *ptr++ = ESC;
 190                         *ptr++ = ESC_ESC;
 191                         break;
 192                 default:
 193                         *ptr++ = c;
 194                         break;
 195                 }
 196         }
 197
 198         *ptr++ = END;
 199
 200         return ptr - d;
 201 }
 202
 203 /*
 204  * MW:
 205  * OK its ugly, but tell me a better solution without copying the
 206  * packet to a temporary buffer :-)
 207  */
 208 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc,
 209         int len)
 210 {
 211         unsigned char *ptr = d;
 212         unsigned char c=0;
 213
 214         *ptr++ = END;
 215         while (len > 0) {
 216                 if (len > 2)
 217                         c = *s++;
 218                 else if (len > 1)
 219                         c = crc >> 8;
 220                 else if (len > 0)
 221                         c = crc & 0xff;
 222
 223                 len--;
 224
 225                 switch (c) {
 226                 case END:
 227                         *ptr++ = ESC;
 228                         *ptr++ = ESC_END;
 229                         break;
 230                 case ESC:
 231                         *ptr++ = ESC;
 232                         *ptr++ = ESC_ESC;
 233                         break;
 234                 default:
 235                         *ptr++ = c;
 236                         break;
 237                 }
 238         }
 239         *ptr++ = END;
 240
 241         return ptr - d;
 242 }
 243
 244 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
 245 static void ax_bump(struct mkiss *ax)
 246 {
 247         unsigned long flags;
 248         struct sk_buff *skb;
 249         int count;
 250
 251         spin_lock_irqsave(&ax->buflock, flags);
 252         if (ax->rbuff[0] > 0x0f) {
 253                 if (ax->rbuff[0] & 0x80) {
 254                         if (check_crc_16(ax->rbuff, ax->rcount) < 0) {
 255                                 ax->dev->stats.rx_errors++;
 256                                 spin_unlock_irqrestore(&ax->buflock, flags);
 257
 258                                 return;
 259                         }
 260                         if (ax->crcmode != CRC_MODE_SMACK && ax->crcauto) {
 261                                 printk(KERN_INFO
 262                                        "mkiss: %s: Switchting to crc-smack\n",
 263                                        ax->dev->name);
 264                                 ax->crcmode = CRC_MODE_SMACK;
 265                         }
 266                         ax->rcount -= 2;
 267                         *ax->rbuff &= ~0x80;
 268                 } else if (ax->rbuff[0] & 0x20)  {
 269                         if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
 270                                 ax->dev->stats.rx_errors++;
 271                                 spin_unlock_irqrestore(&ax->buflock, flags);
 272                                 return;
 273                         }
 274                         if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) {
 275                                 printk(KERN_INFO
 276                                        "mkiss: %s: Switchting to crc-flexnet\n",
 277                                        ax->dev->name);
 278                                 ax->crcmode = CRC_MODE_FLEX;
 279                         }
 280                         ax->rcount -= 2;
 281
 282                         /*
 283                          * dl9sau bugfix: the trailling two bytes flexnet crc
 284                          * will not be passed to the kernel. thus we have to
 285                          * correct the kissparm signature, because it indicates
 286                          * a crc but there's none
 287                          */
 288                         *ax->rbuff &= ~0x20;
 289                 }
 290         }
 291
 292         count = ax->rcount;
 293
 294         if ((skb = dev_alloc_skb(count)) == NULL) {
 295                 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n",
 296                        ax->dev->name);
 297                 ax->dev->stats.rx_dropped++;
 298                 spin_unlock_irqrestore(&ax->buflock, flags);
 299                 return;
 300         }
 301
 302         memcpy(skb_put(skb,count), ax->rbuff, count);
 303         skb->protocol = ax25_type_trans(skb, ax->dev);
 304         netif_rx(skb);
 305         ax->dev->stats.rx_packets++;
 306         ax->dev->stats.rx_bytes += count;
 307         spin_unlock_irqrestore(&ax->buflock, flags);
 308 }
 309
 310 static void kiss_unesc(struct mkiss *ax, unsigned char s)
 311 {
 312         unsigned long flags;
 313
 314         switch (s) {
 315         case END:
 316                 /* drop keeptest bit = VSV */
 317                 if (test_bit(AXF_KEEPTEST, &ax->flags))
 318                         clear_bit(AXF_KEEPTEST, &ax->flags);
 319
 320                 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
 321                         ax_bump(ax);
 322
 323                 clear_bit(AXF_ESCAPE, &ax->flags);
 324                 ax->rcount = 0;
 325                 return;
 326
 327         case ESC:
 328                 set_bit(AXF_ESCAPE, &ax->flags);
 329                 return;
 330         case ESC_ESC:
 331                 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 332                         s = ESC;
 333                 break;
 334         case ESC_END:
 335                 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 336                         s = END;
 337                 break;
 338         }
 339
 340         spin_lock_irqsave(&ax->buflock, flags);
 341         if (!test_bit(AXF_ERROR, &ax->flags)) {
 342                 if (ax->rcount < ax->buffsize) {
 343                         ax->rbuff[ax->rcount++] = s;
 344                         spin_unlock_irqrestore(&ax->buflock, flags);
 345                         return;
 346                 }
 347
 348                 ax->dev->stats.rx_over_errors++;
 349                 set_bit(AXF_ERROR, &ax->flags);
 350         }
 351         spin_unlock_irqrestore(&ax->buflock, flags);
 352 }
 353
 354 static int ax_set_mac_address(struct net_device *dev, void *addr)
 355 {
 356         struct sockaddr_ax25 *sa = addr;
 357
 358         netif_tx_lock_bh(dev);
 359         netif_addr_lock(dev);
 360         memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
 361         netif_addr_unlock(dev);
 362         netif_tx_unlock_bh(dev);
 363
 364         return 0;
 365 }
 366
 367 /*---------------------------------------------------------------------------*/
 368
 369 static void ax_changedmtu(struct mkiss *ax)
 370 {
 371         struct net_device *dev = ax->dev;
 372         unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
 373         unsigned long flags;
 374         int len;
 375
 376         len = dev->mtu * 2;
 377
 378         /*
 379          * allow for arrival of larger UDP packets, even if we say not to
 380          * also fixes a bug in which SunOS sends 512-byte packets even with
 381          * an MSS of 128
 382          */
 383         if (len < 576 * 2)
 384                 len = 576 * 2;
 385
 386         xbuff = kmalloc(len + 4, GFP_ATOMIC);
 387         rbuff = kmalloc(len + 4, GFP_ATOMIC);
 388
 389         if (xbuff == NULL || rbuff == NULL)  {
 390                 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, "
 391                        "MTU change cancelled.\n",
 392                        ax->dev->name);
 393                 dev->mtu = ax->mtu;
 394                 kfree(xbuff);
 395                 kfree(rbuff);
 396                 return;
 397         }
 398
 399         spin_lock_irqsave(&ax->buflock, flags);
 400
 401         oxbuff    = ax->xbuff;
 402         ax->xbuff = xbuff;
 403         orbuff    = ax->rbuff;
 404         ax->rbuff = rbuff;
 405
 406         if (ax->xleft) {
 407                 if (ax->xleft <= len) {
 408                         memcpy(ax->xbuff, ax->xhead, ax->xleft);
 409                 } else  {
 410                         ax->xleft = 0;
 411                         dev->stats.tx_dropped++;
 412                 }
 413         }
 414
 415         ax->xhead = ax->xbuff;
 416
 417         if (ax->rcount) {
 418                 if (ax->rcount <= len) {
 419                         memcpy(ax->rbuff, orbuff, ax->rcount);
 420                 } else  {
 421                         ax->rcount = 0;
 422                         dev->stats.rx_over_errors++;
 423                         set_bit(AXF_ERROR, &ax->flags);
 424                 }
 425         }
 426
 427         ax->mtu      = dev->mtu + 73;
 428         ax->buffsize = len;
 429
 430         spin_unlock_irqrestore(&ax->buflock, flags);
 431
 432         kfree(oxbuff);
 433         kfree(orbuff);
 434 }
 435
 436 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
 437 static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
 438 {
 439         struct mkiss *ax = netdev_priv(dev);
 440         unsigned long flags;
 441         unsigned char *p;
 442         int actual, count;
 443
 444         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
 445                 ax_changedmtu(ax);
 446
 447         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
 448                 len = ax->mtu;
 449                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
 450                 dev->stats.tx_dropped++;
 451                 netif_start_queue(dev);
 452                 return;
 453         }
 454
 455         p = icp;
 456
 457         spin_lock_irqsave(&ax->buflock, flags);
 458         if ((*p & 0x0f) != 0) {
 459                 /* Configuration Command (kissparms(1).
 460                  * Protocol spec says: never append CRC.
 461                  * This fixes a very old bug in the linux
 462                  * kiss driver. -- dl9sau */
 463                 switch (*p & 0xff) {
 464                 case 0x85:
 465                         /* command from userspace especially for us,
 466                          * not for delivery to the tnc */
 467                         if (len > 1) {
 468                                 int cmd = (p[1] & 0xff);
 469                                 switch(cmd) {
 470                                 case 3:
 471                                   ax->crcmode = CRC_MODE_SMACK;
 472                                   break;
 473                                 case 2:
 474                                   ax->crcmode = CRC_MODE_FLEX;
 475                                   break;
 476                                 case 1:
 477                                   ax->crcmode = CRC_MODE_NONE;
 478                                   break;
 479                                 case 0:
 480                                 default:
 481                                   ax->crcmode = CRC_MODE_SMACK_TEST;
 482                                   cmd = 0;
 483                                 }
 484                                 ax->crcauto = (cmd ? 0 : 1);
 485                                 printk(KERN_INFO "mkiss: %s: crc mode %s %d\n", ax->dev->name, (len) ? "set to" : "is", cmd);
 486                         }
 487                         spin_unlock_irqrestore(&ax->buflock, flags);
 488                         netif_start_queue(dev);
 489
 490                         return;
 491                 default:
 492                         count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
 493                 }
 494         } else {
 495                 unsigned short crc;
 496                 switch (ax->crcmode) {
 497                 case CRC_MODE_SMACK_TEST:
 498                         ax->crcmode  = CRC_MODE_FLEX_TEST;
 499                         printk(KERN_INFO "mkiss: %s: Trying crc-smack\n", ax->dev->name);
 500                         // fall through
 501                 case CRC_MODE_SMACK:
 502                         *p |= 0x80;
 503                         crc = swab16(crc16(0, p, len));
 504                         count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
 505                         break;
 506                 case CRC_MODE_FLEX_TEST:
 507                         ax->crcmode = CRC_MODE_NONE;
 508                         printk(KERN_INFO "mkiss: %s: Trying crc-flexnet\n", ax->dev->name);
 509                         // fall through
 510                 case CRC_MODE_FLEX:
 511                         *p |= 0x20;
 512                         crc = calc_crc_flex(p, len);
 513                         count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
 514                         break;
 515
 516                 default:
 517                         count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
 518                 }
 519         }
 520         spin_unlock_irqrestore(&ax->buflock, flags);
 521
 522         set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
 523         actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
 524         dev->stats.tx_packets++;
 525         dev->stats.tx_bytes += actual;
 526
 527         ax->dev->trans_start = jiffies;
 528         ax->xleft = count - actual;
 529         ax->xhead = ax->xbuff + actual;
 530 }
 531
 532 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
 533 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
 534 {
 535         struct mkiss *ax = netdev_priv(dev);
 536
 537         if (!netif_running(dev))  {
 538                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
 539                 return NETDEV_TX_BUSY;
 540         }
 541
 542         if (netif_queue_stopped(dev)) {
 543                 /*
 544                  * May be we must check transmitter timeout here ?
 545                  *      14 Oct 1994 Dmitry Gorodchanin.
 546                  */
 547                 if (time_before(jiffies, dev->trans_start + 20 * HZ)) {
 548                         /* 20 sec timeout not reached */
 549                         return NETDEV_TX_BUSY;
 550                 }
 551
 552                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
 553                        (tty_chars_in_buffer(ax->tty) || ax->xleft) ?
 554                        "bad line quality" : "driver error");
 555
 556                 ax->xleft = 0;
 557                 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
 558                 netif_start_queue(dev);
 559         }
 560
 561         /* We were not busy, so we are now... :-) */
 562         if (skb != NULL) {
 563                 netif_stop_queue(dev);
 564                 ax_encaps(dev, skb->data, skb->len);
 565                 kfree_skb(skb);
 566         }
 567
 568         return 0;
 569 }
 570
 571 static int ax_open_dev(struct net_device *dev)
 572 {
 573         struct mkiss *ax = netdev_priv(dev);
 574
 575         if (ax->tty == NULL)
 576                 return -ENODEV;
 577
 578         return 0;
 579 }
 580
 581 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 582
 583 /* Return the frame type ID */
 584 static int ax_header(struct sk_buff *skb, struct net_device *dev,
 585                      unsigned short type, const void *daddr,
 586                      const void *saddr, unsigned len)
 587 {
 588 #ifdef CONFIG_INET
 589         if (type != ETH_P_AX25)
 590                 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
 591 #endif
 592         return 0;
 593 }
 594
 595
 596 static int ax_rebuild_header(struct sk_buff *skb)
 597 {
 598 #ifdef CONFIG_INET
 599         return ax25_rebuild_header(skb);
 600 #else
 601         return 0;
 602 #endif
 603 }
 604
 605 #endif  /* CONFIG_{AX25,AX25_MODULE} */
 606
 607 /* Open the low-level part of the AX25 channel. Easy! */
 608 static int ax_open(struct net_device *dev)
 609 {
 610         struct mkiss *ax = netdev_priv(dev);
 611         unsigned long len;
 612
 613         if (ax->tty == NULL)
 614                 return -ENODEV;
 615
 616         /*
 617          * Allocate the frame buffers:
 618          *
 619          * rbuff        Receive buffer.
 620          * xbuff        Transmit buffer.
 621          */
 622         len = dev->mtu * 2;
 623
 624         /*
 625          * allow for arrival of larger UDP packets, even if we say not to
 626          * also fixes a bug in which SunOS sends 512-byte packets even with
 627          * an MSS of 128
 628          */
 629         if (len < 576 * 2)
 630                 len = 576 * 2;
 631
 632         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 633                 goto norbuff;
 634
 635         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 636                 goto noxbuff;
 637
 638         ax->mtu      = dev->mtu + 73;
 639         ax->buffsize = len;
 640         ax->rcount   = 0;
 641         ax->xleft    = 0;
 642
 643         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
 644
 645         spin_lock_init(&ax->buflock);
 646
 647         return 0;
 648
 649 noxbuff:
 650         kfree(ax->rbuff);
 651
 652 norbuff:
 653         return -ENOMEM;
 654 }
 655
 656
 657 /* Close the low-level part of the AX25 channel. Easy! */
 658 static int ax_close(struct net_device *dev)
 659 {
 660         struct mkiss *ax = netdev_priv(dev);
 661
 662         if (ax->tty)
 663                 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
 664
 665         netif_stop_queue(dev);
 666
 667         return 0;
 668 }
 669
 670 static const struct header_ops ax_header_ops = {
 671         .create    = ax_header,
 672         .rebuild   = ax_rebuild_header,
 673 };
 674
 675 static const struct net_device_ops ax_netdev_ops = {
 676         .ndo_open            = ax_open_dev,
 677         .ndo_stop            = ax_close,
 678         .ndo_start_xmit      = ax_xmit,
 679         .ndo_set_mac_address = ax_set_mac_address,
 680 };
 681
 682 static void ax_setup(struct net_device *dev)
 683 {
 684         /* Finish setting up the DEVICE info. */
 685         dev->mtu             = AX_MTU;
 686         dev->hard_header_len = 0;
 687         dev->addr_len        = 0;
 688         dev->type            = ARPHRD_AX25;
 689         dev->tx_queue_len    = 10;
 690         dev->header_ops      = &ax_header_ops;
 691         dev->netdev_ops      = &ax_netdev_ops;
 692
 693
 694         memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
 695         memcpy(dev->dev_addr,  &ax25_defaddr,  AX25_ADDR_LEN);
 696
 697         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
 698 }
 699
 700 /*
 701  * We have a potential race on dereferencing tty->disc_data, because the tty
 702  * layer provides no locking at all - thus one cpu could be running
 703  * sixpack_receive_buf while another calls sixpack_close, which zeroes
 704  * tty->disc_data and frees the memory that sixpack_receive_buf is using.  The
 705  * best way to fix this is to use a rwlock in the tty struct, but for now we
 706  * use a single global rwlock for all ttys in ppp line discipline.
 707  */
 708 static DEFINE_RWLOCK(disc_data_lock);
 709
 710 static struct mkiss *mkiss_get(struct tty_struct *tty)
 711 {
 712         unsigned long flags;
 713         struct mkiss *ax;
 714
 715         read_lock_irqsave(&disc_data_lock, flags);
 716         ax = tty->disc_data;
 717         if (ax)
 718                 atomic_inc(&ax->refcnt);
 719         read_unlock_irqrestore(&disc_data_lock, flags);
 720
 721         return ax;
 722 }
 723
 724 static void mkiss_put(struct mkiss *ax)
 725 {
 726         if (atomic_dec_and_test(&ax->refcnt))
 727                 up(&ax->dead_sem);
 728 }
 729
 730 static int crc_force = 0;       /* Can be overridden with insmod */
 731
 732 static int mkiss_open(struct tty_struct *tty)
 733 {
 734         struct net_device *dev;
 735         struct mkiss *ax;
 736         int err;
 737
 738         if (!capable(CAP_NET_ADMIN))
 739                 return -EPERM;
 740         if (tty->ops->write == NULL)
 741                 return -EOPNOTSUPP;
 742
 743         dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup);
 744         if (!dev) {
 745                 err = -ENOMEM;
 746                 goto out;
 747         }
 748
 749         ax = netdev_priv(dev);
 750         ax->dev = dev;
 751
 752         spin_lock_init(&ax->buflock);
 753         atomic_set(&ax->refcnt, 1);
 754         init_MUTEX_LOCKED(&ax->dead_sem);
 755
 756         ax->tty = tty;
 757         tty->disc_data = ax;
 758         tty->receive_room = 65535;
 759
 760         tty_driver_flush_buffer(tty);
 761
 762         /* Restore default settings */
 763         dev->type = ARPHRD_AX25;
 764
 765         /* Perform the low-level AX25 initialization. */
 766         if ((err = ax_open(ax->dev))) {
 767                 goto out_free_netdev;
 768         }
 769
 770         if (register_netdev(dev))
 771                 goto out_free_buffers;
 772
 773         /* after register_netdev() - because else printk smashes the kernel */
 774         switch (crc_force) {
 775         case 3:
 776                 ax->crcmode  = CRC_MODE_SMACK;
 777                 printk(KERN_INFO "mkiss: %s: crc mode smack forced.\n",
 778                        ax->dev->name);
 779                 break;
 780         case 2:
 781                 ax->crcmode  = CRC_MODE_FLEX;
 782                 printk(KERN_INFO "mkiss: %s: crc mode flexnet forced.\n",
 783                        ax->dev->name);
 784                 break;
 785         case 1:
 786                 ax->crcmode  = CRC_MODE_NONE;
 787                 printk(KERN_INFO "mkiss: %s: crc mode disabled.\n",
 788                        ax->dev->name);
 789                 break;
 790         case 0:
 791                 /* fall through */
 792         default:
 793                 crc_force = 0;
 794                 printk(KERN_INFO "mkiss: %s: crc mode is auto.\n",
 795                        ax->dev->name);
 796                 ax->crcmode  = CRC_MODE_SMACK_TEST;
 797         }
 798         ax->crcauto = (crc_force ? 0 : 1);
 799
 800         netif_start_queue(dev);
 801
 802         /* Done.  We have linked the TTY line to a channel. */
 803         return 0;
 804
 805 out_free_buffers:
 806         kfree(ax->rbuff);
 807         kfree(ax->xbuff);
 808
 809 out_free_netdev:
 810         free_netdev(dev);
 811
 812 out:
 813         return err;
 814 }
 815
 816 static void mkiss_close(struct tty_struct *tty)
 817 {
 818         unsigned long flags;
 819         struct mkiss *ax;
 820
 821         write_lock_irqsave(&disc_data_lock, flags);
 822         ax = tty->disc_data;
 823         tty->disc_data = NULL;
 824         write_unlock_irqrestore(&disc_data_lock, flags);
 825
 826         if (!ax)
 827                 return;
 828
 829         /*
 830          * We have now ensured that nobody can start using ap from now on, but
 831          * we have to wait for all existing users to finish.
 832          */
 833         if (!atomic_dec_and_test(&ax->refcnt))
 834                 down(&ax->dead_sem);
 835
 836         unregister_netdev(ax->dev);
 837
 838         /* Free all AX25 frame buffers. */
 839         kfree(ax->rbuff);
 840         kfree(ax->xbuff);
 841
 842         ax->tty = NULL;
 843 }
 844
 845 /* Perform I/O control on an active ax25 channel. */
 846 static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
 847         unsigned int cmd, unsigned long arg)
 848 {
 849         struct mkiss *ax = mkiss_get(tty);
 850         struct net_device *dev;
 851         unsigned int tmp, err;
 852
 853         /* First make sure we're connected. */
 854         if (ax == NULL)
 855                 return -ENXIO;
 856         dev = ax->dev;
 857
 858         switch (cmd) {
 859         case SIOCGIFNAME:
 860                 err = copy_to_user((void __user *) arg, ax->dev->name,
 861                                    strlen(ax->dev->name) + 1) ? -EFAULT : 0;
 862                 break;
 863
 864         case SIOCGIFENCAP:
 865                 err = put_user(4, (int __user *) arg);
 866                 break;
 867
 868         case SIOCSIFENCAP:
 869                 if (get_user(tmp, (int __user *) arg)) {
 870                         err = -EFAULT;
 871                         break;
 872                 }
 873
 874                 ax->mode = tmp;
 875                 dev->addr_len        = AX25_ADDR_LEN;
 876                 dev->hard_header_len = AX25_KISS_HEADER_LEN +
 877                                        AX25_MAX_HEADER_LEN + 3;
 878                 dev->type            = ARPHRD_AX25;
 879
 880                 err = 0;
 881                 break;
 882
 883         case SIOCSIFHWADDR: {
 884                 char addr[AX25_ADDR_LEN];
 885
 886                 if (copy_from_user(&addr,
 887                                    (void __user *) arg, AX25_ADDR_LEN)) {
 888                         err = -EFAULT;
 889                         break;
 890                 }
 891
 892                 netif_tx_lock_bh(dev);
 893                 memcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
 894                 netif_tx_unlock_bh(dev);
 895
 896                 err = 0;
 897                 break;
 898         }
 899         default:
 900                 err = -ENOIOCTLCMD;
 901         }
 902
 903         mkiss_put(ax);
 904
 905         return err;
 906 }
 907
 908 /*
 909  * Handle the 'receiver data ready' interrupt.
 910  * This function is called by the 'tty_io' module in the kernel when
 911  * a block of data has been received, which can now be decapsulated
 912  * and sent on to the AX.25 layer for further processing.
 913  */
 914 static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 915         char *fp, int count)
 916 {
 917         struct mkiss *ax = mkiss_get(tty);
 918
 919         if (!ax)
 920                 return;
 921
 922         /*
 923          * Argh! mtu change time! - costs us the packet part received
 924          * at the change
 925          */
 926         if (ax->mtu != ax->dev->mtu + 73)
 927                 ax_changedmtu(ax);
 928
 929         /* Read the characters out of the buffer */
 930         while (count--) {
 931                 if (fp != NULL && *fp++) {
 932                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
 933                                 ax->dev->stats.rx_errors++;
 934                         cp++;
 935                         continue;
 936                 }
 937
 938                 kiss_unesc(ax, *cp++);
 939         }
 940
 941         mkiss_put(ax);
 942         tty_unthrottle(tty);
 943 }
 944
 945 /*
 946  * Called by the driver when there's room for more data.  If we have
 947  * more packets to send, we send them here.
 948  */
 949 static void mkiss_write_wakeup(struct tty_struct *tty)
 950 {
 951         struct mkiss *ax = mkiss_get(tty);
 952         int actual;
 953
 954         if (!ax)
 955                 return;
 956
 957         if (ax->xleft <= 0)  {
 958                 /* Now serial buffer is almost free & we can start
 959                  * transmission of another packet
 960                  */
 961                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 962
 963                 netif_wake_queue(ax->dev);
 964                 goto out;
 965         }
 966
 967         actual = tty->ops->write(tty, ax->xhead, ax->xleft);
 968         ax->xleft -= actual;
 969         ax->xhead += actual;
 970
 971 out:
 972         mkiss_put(ax);
 973 }
 974
 975 static struct tty_ldisc_ops ax_ldisc = {
 976         .owner          = THIS_MODULE,
 977         .magic          = TTY_LDISC_MAGIC,
 978         .name           = "mkiss",
 979         .open           = mkiss_open,
 980         .close          = mkiss_close,
 981         .ioctl          = mkiss_ioctl,
 982         .receive_buf    = mkiss_receive_buf,
 983         .write_wakeup   = mkiss_write_wakeup
 984 };
 985
 986 static const char banner[] __initdata = KERN_INFO \
 987         "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
 988 static const char msg_regfail[] __initdata = KERN_ERR \
 989         "mkiss: can't register line discipline (err = %d)\n";
 990
 991 static int __init mkiss_init_driver(void)
 992 {
 993         int status;
 994
 995         printk(banner);
 996
 997         status = tty_register_ldisc(N_AX25, &ax_ldisc);
 998         if (status != 0)
 999                 printk(msg_regfail, status);
1000
1001         return status;
1002 }
1003
1004 static const char msg_unregfail[] __exitdata = KERN_ERR \
1005         "mkiss: can't unregister line discipline (err = %d)\n";
1006
1007 static void __exit mkiss_exit_driver(void)
1008 {
1009         int ret;
1010
1011         if ((ret = tty_unregister_ldisc(N_AX25)))
1012                 printk(msg_unregfail, ret);
1013 }
1014
1015 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
1016 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
1017 module_param(crc_force, int, 0);
1018 MODULE_PARM_DESC(crc_force, "crc [0 = auto | 1 = none | 2 = flexnet | 3 = smack]");
1019 MODULE_LICENSE("GPL");
1020 MODULE_ALIAS_LDISC(N_AX25);
1021
1022 module_init(mkiss_init_driver);
1023 module_exit(mkiss_exit_driver);