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