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