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