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  */
  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/string.h>
  25 #include <linux/mm.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/in.h>
  28 #include <linux/inet.h>
  29 #include <linux/tty.h>
  30 #include <linux/errno.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/major.h>
  33 #include <linux/init.h>
  34 #include <linux/rtnetlink.h>
  35 #include <linux/etherdevice.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/if_arp.h>
  38 #include <linux/jiffies.h>
  39
  40 #include <net/ax25.h>
  41
  42 #ifdef CONFIG_INET
  43 #include <linux/ip.h>
  44 #include <linux/tcp.h>
  45 #endif
  46
  47 #define AX_MTU          236
  48
  49 /* SLIP/KISS protocol characters. */
  50 #define END             0300            /* indicates end of frame       */
  51 #define ESC             0333            /* indicates byte stuffing      */
  52 #define ESC_END         0334            /* ESC ESC_END means END 'data' */
  53 #define ESC_ESC         0335            /* ESC ESC_ESC means ESC 'data' */
  54
  55 struct mkiss {
  56         struct tty_struct       *tty;   /* ptr to TTY structure         */
  57         struct net_device       *dev;   /* easy for intr handling       */
  58
  59         /* These are pointers to the malloc()ed frame buffers. */
  60         spinlock_t              buflock;/* lock for rbuf and xbuf */
  61         unsigned char           *rbuff; /* receiver buffer              */
  62         int                     rcount; /* received chars counter       */
  63         unsigned char           *xbuff; /* transmitter buffer           */
  64         unsigned char           *xhead; /* pointer to next byte to XMIT */
  65         int                     xleft;  /* bytes left in XMIT queue     */
  66
  67         struct net_device_stats stats;
  68
  69         /* Detailed SLIP statistics. */
  70         int             mtu;            /* Our mtu (to spot changes!)   */
  71         int             buffsize;       /* Max buffers sizes            */
  72
  73         unsigned long   flags;          /* Flag values/ mode etc        */
  74                                         /* long req'd: used by set_bit --RR */
  75 #define AXF_INUSE       0               /* Channel in use               */
  76 #define AXF_ESCAPE      1               /* ESC received                 */
  77 #define AXF_ERROR       2               /* Parity, etc. error           */
  78 #define AXF_KEEPTEST    3               /* Keepalive test flag          */
  79 #define AXF_OUTWAIT     4               /* is outpacket was flag        */
  80
  81         int             mode;
  82         int             crcmode;        /* MW: for FlexNet, SMACK etc.  */
  83 #define CRC_MODE_NONE   0
  84 #define CRC_MODE_FLEX   1
  85 #define CRC_MODE_SMACK  2
  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 /*
 155  * Standard encapsulation
 156  */
 157
 158 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
 159 {
 160         unsigned char *ptr = d;
 161         unsigned char c;
 162
 163         /*
 164          * Send an initial END character to flush out any data that may have
 165          * accumulated in the receiver due to line noise.
 166          */
 167
 168         *ptr++ = END;
 169
 170         while (len-- > 0) {
 171                 switch (c = *s++) {
 172                 case END:
 173                         *ptr++ = ESC;
 174                         *ptr++ = ESC_END;
 175                         break;
 176                 case ESC:
 177                         *ptr++ = ESC;
 178                         *ptr++ = ESC_ESC;
 179                         break;
 180                 default:
 181                         *ptr++ = c;
 182                         break;
 183                 }
 184         }
 185
 186         *ptr++ = END;
 187
 188         return ptr - d;
 189 }
 190
 191 /*
 192  * MW:
 193  * OK its ugly, but tell me a better solution without copying the
 194  * packet to a temporary buffer :-)
 195  */
 196 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc,
 197         int len)
 198 {
 199         unsigned char *ptr = d;
 200         unsigned char c=0;
 201
 202         *ptr++ = END;
 203         while (len > 0) {
 204                 if (len > 2)
 205                         c = *s++;
 206                 else if (len > 1)
 207                         c = crc >> 8;
 208                 else if (len > 0)
 209                         c = crc & 0xff;
 210
 211                 len--;
 212
 213                 switch (c) {
 214                 case END:
 215                         *ptr++ = ESC;
 216                         *ptr++ = ESC_END;
 217                         break;
 218                 case ESC:
 219                         *ptr++ = ESC;
 220                         *ptr++ = ESC_ESC;
 221                         break;
 222                 default:
 223                         *ptr++ = c;
 224                         break;
 225                 }
 226         }
 227         *ptr++ = END;
 228
 229         return ptr - d;
 230 }
 231
 232 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
 233 static void ax_bump(struct mkiss *ax)
 234 {
 235         struct sk_buff *skb;
 236         int count;
 237
 238         spin_lock_bh(&ax->buflock);
 239         if (ax->rbuff[0] > 0x0f) {
 240                 if (ax->rbuff[0] & 0x20) {
 241                         ax->crcmode = CRC_MODE_FLEX;
 242                         if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
 243                                 ax->stats.rx_errors++;
 244                                 return;
 245                         }
 246                         ax->rcount -= 2;
 247                         /* dl9sau bugfix: the trailling two bytes flexnet crc
 248                          * will not be passed to the kernel. thus we have
 249                          * to correct the kissparm signature, because it
 250                          * indicates a crc but there's none
 251                          */
 252                         *ax->rbuff &= ~0x20;
 253                 }
 254         }
 255         spin_unlock_bh(&ax->buflock);
 256
 257         count = ax->rcount;
 258
 259         if ((skb = dev_alloc_skb(count)) == NULL) {
 260                 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n",
 261                        ax->dev->name);
 262                 ax->stats.rx_dropped++;
 263                 return;
 264         }
 265
 266         spin_lock_bh(&ax->buflock);
 267         memcpy(skb_put(skb,count), ax->rbuff, count);
 268         spin_unlock_bh(&ax->buflock);
 269         skb->protocol = ax25_type_trans(skb, ax->dev);
 270         netif_rx(skb);
 271         ax->dev->last_rx = jiffies;
 272         ax->stats.rx_packets++;
 273         ax->stats.rx_bytes += count;
 274 }
 275
 276 static void kiss_unesc(struct mkiss *ax, unsigned char s)
 277 {
 278         switch (s) {
 279         case END:
 280                 /* drop keeptest bit = VSV */
 281                 if (test_bit(AXF_KEEPTEST, &ax->flags))
 282                         clear_bit(AXF_KEEPTEST, &ax->flags);
 283
 284                 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
 285                         ax_bump(ax);
 286
 287                 clear_bit(AXF_ESCAPE, &ax->flags);
 288                 ax->rcount = 0;
 289                 return;
 290
 291         case ESC:
 292                 set_bit(AXF_ESCAPE, &ax->flags);
 293                 return;
 294         case ESC_ESC:
 295                 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 296                         s = ESC;
 297                 break;
 298         case ESC_END:
 299                 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
 300                         s = END;
 301                 break;
 302         }
 303
 304         spin_lock_bh(&ax->buflock);
 305         if (!test_bit(AXF_ERROR, &ax->flags)) {
 306                 if (ax->rcount < ax->buffsize) {
 307                         ax->rbuff[ax->rcount++] = s;
 308                         spin_unlock_bh(&ax->buflock);
 309                         return;
 310                 }
 311
 312                 ax->stats.rx_over_errors++;
 313                 set_bit(AXF_ERROR, &ax->flags);
 314         }
 315         spin_unlock_bh(&ax->buflock);
 316 }
 317
 318 static int ax_set_mac_address(struct net_device *dev, void *addr)
 319 {
 320         struct sockaddr_ax25 *sa = addr;
 321
 322         spin_lock_irq(&dev->xmit_lock);
 323         memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
 324         spin_unlock_irq(&dev->xmit_lock);
 325
 326         return 0;
 327 }
 328
 329 /*---------------------------------------------------------------------------*/
 330
 331 static void ax_changedmtu(struct mkiss *ax)
 332 {
 333         struct net_device *dev = ax->dev;
 334         unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
 335         int len;
 336
 337         len = dev->mtu * 2;
 338
 339         /*
 340          * allow for arrival of larger UDP packets, even if we say not to
 341          * also fixes a bug in which SunOS sends 512-byte packets even with
 342          * an MSS of 128
 343          */
 344         if (len < 576 * 2)
 345                 len = 576 * 2;
 346
 347         xbuff = kmalloc(len + 4, GFP_ATOMIC);
 348         rbuff = kmalloc(len + 4, GFP_ATOMIC);
 349
 350         if (xbuff == NULL || rbuff == NULL)  {
 351                 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, "
 352                        "MTU change cancelled.\n",
 353                        ax->dev->name);
 354                 dev->mtu = ax->mtu;
 355                 if (xbuff != NULL)
 356                         kfree(xbuff);
 357                 if (rbuff != NULL)
 358                         kfree(rbuff);
 359                 return;
 360         }
 361
 362         spin_lock_bh(&ax->buflock);
 363
 364         oxbuff    = ax->xbuff;
 365         ax->xbuff = xbuff;
 366         orbuff    = ax->rbuff;
 367         ax->rbuff = rbuff;
 368
 369         if (ax->xleft) {
 370                 if (ax->xleft <= len) {
 371                         memcpy(ax->xbuff, ax->xhead, ax->xleft);
 372                 } else  {
 373                         ax->xleft = 0;
 374                         ax->stats.tx_dropped++;
 375                 }
 376         }
 377
 378         ax->xhead = ax->xbuff;
 379
 380         if (ax->rcount) {
 381                 if (ax->rcount <= len) {
 382                         memcpy(ax->rbuff, orbuff, ax->rcount);
 383                 } else  {
 384                         ax->rcount = 0;
 385                         ax->stats.rx_over_errors++;
 386                         set_bit(AXF_ERROR, &ax->flags);
 387                 }
 388         }
 389
 390         ax->mtu      = dev->mtu + 73;
 391         ax->buffsize = len;
 392
 393         spin_unlock_bh(&ax->buflock);
 394
 395         kfree(oxbuff);
 396         kfree(orbuff);
 397 }
 398
 399 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
 400 static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
 401 {
 402         struct mkiss *ax = netdev_priv(dev);
 403         unsigned char *p;
 404         int actual, count;
 405
 406         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
 407                 ax_changedmtu(ax);
 408
 409         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
 410                 len = ax->mtu;
 411                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
 412                 ax->stats.tx_dropped++;
 413                 netif_start_queue(dev);
 414                 return;
 415         }
 416
 417         p = icp;
 418
 419         spin_lock_bh(&ax->buflock);
 420         switch (ax->crcmode) {
 421                  unsigned short crc;
 422
 423         case CRC_MODE_FLEX:
 424                  *p |= 0x20;
 425                  crc = calc_crc_flex(p, len);
 426                  count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
 427                  break;
 428
 429         default:
 430                  count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
 431                  break;
 432         }
 433
 434         set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
 435         actual = ax->tty->driver->write(ax->tty, ax->xbuff, count);
 436         ax->stats.tx_packets++;
 437         ax->stats.tx_bytes += actual;
 438
 439         ax->dev->trans_start = jiffies;
 440         ax->xleft = count - actual;
 441         ax->xhead = ax->xbuff + actual;
 442
 443         spin_unlock_bh(&ax->buflock);
 444 }
 445
 446 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
 447 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
 448 {
 449         struct mkiss *ax = netdev_priv(dev);
 450
 451         if (!netif_running(dev))  {
 452                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
 453                 return 1;
 454         }
 455
 456         if (netif_queue_stopped(dev)) {
 457                 /*
 458                  * May be we must check transmitter timeout here ?
 459                  *      14 Oct 1994 Dmitry Gorodchanin.
 460                  */
 461                 if (time_before(jiffies, dev->trans_start + 20 * HZ)) {
 462                         /* 20 sec timeout not reached */
 463                         return 1;
 464                 }
 465
 466                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
 467                        (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
 468                        "bad line quality" : "driver error");
 469
 470                 ax->xleft = 0;
 471                 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
 472                 netif_start_queue(dev);
 473         }
 474
 475         /* We were not busy, so we are now... :-) */
 476         if (skb != NULL) {
 477                 netif_stop_queue(dev);
 478                 ax_encaps(dev, skb->data, skb->len);
 479                 kfree_skb(skb);
 480         }
 481
 482         return 0;
 483 }
 484
 485 static int ax_open_dev(struct net_device *dev)
 486 {
 487         struct mkiss *ax = netdev_priv(dev);
 488
 489         if (ax->tty == NULL)
 490                 return -ENODEV;
 491
 492         return 0;
 493 }
 494
 495 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 496
 497 /* Return the frame type ID */
 498 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
 499           void *daddr, void *saddr, unsigned len)
 500 {
 501 #ifdef CONFIG_INET
 502         if (type != htons(ETH_P_AX25))
 503                 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
 504 #endif
 505         return 0;
 506 }
 507
 508
 509 static int ax_rebuild_header(struct sk_buff *skb)
 510 {
 511 #ifdef CONFIG_INET
 512         return ax25_rebuild_header(skb);
 513 #else
 514         return 0;
 515 #endif
 516 }
 517
 518 #endif  /* CONFIG_{AX25,AX25_MODULE} */
 519
 520 /* Open the low-level part of the AX25 channel. Easy! */
 521 static int ax_open(struct net_device *dev)
 522 {
 523         struct mkiss *ax = netdev_priv(dev);
 524         unsigned long len;
 525
 526         if (ax->tty == NULL)
 527                 return -ENODEV;
 528
 529         /*
 530          * Allocate the frame buffers:
 531          *
 532          * rbuff        Receive buffer.
 533          * xbuff        Transmit buffer.
 534          */
 535         len = dev->mtu * 2;
 536
 537         /*
 538          * allow for arrival of larger UDP packets, even if we say not to
 539          * also fixes a bug in which SunOS sends 512-byte packets even with
 540          * an MSS of 128
 541          */
 542         if (len < 576 * 2)
 543                 len = 576 * 2;
 544
 545         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 546                 goto norbuff;
 547
 548         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
 549                 goto noxbuff;
 550
 551         ax->mtu      = dev->mtu + 73;
 552         ax->buffsize = len;
 553         ax->rcount   = 0;
 554         ax->xleft    = 0;
 555
 556         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
 557
 558         spin_lock_init(&ax->buflock);
 559
 560         return 0;
 561
 562 noxbuff:
 563         kfree(ax->rbuff);
 564
 565 norbuff:
 566         return -ENOMEM;
 567 }
 568
 569
 570 /* Close the low-level part of the AX25 channel. Easy! */
 571 static int ax_close(struct net_device *dev)
 572 {
 573         struct mkiss *ax = netdev_priv(dev);
 574
 575         if (ax->tty)
 576                 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
 577
 578         netif_stop_queue(dev);
 579
 580         return 0;
 581 }
 582
 583 static struct net_device_stats *ax_get_stats(struct net_device *dev)
 584 {
 585         struct mkiss *ax = netdev_priv(dev);
 586
 587         return &ax->stats;
 588 }
 589
 590 static void ax_setup(struct net_device *dev)
 591 {
 592         static char ax25_bcast[AX25_ADDR_LEN] =
 593                 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
 594         static char ax25_test[AX25_ADDR_LEN] =
 595                 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
 596
 597         /* Finish setting up the DEVICE info. */
 598         dev->mtu             = AX_MTU;
 599         dev->hard_start_xmit = ax_xmit;
 600         dev->open            = ax_open_dev;
 601         dev->stop            = ax_close;
 602         dev->get_stats       = ax_get_stats;
 603         dev->set_mac_address = ax_set_mac_address;
 604         dev->hard_header_len = 0;
 605         dev->addr_len        = 0;
 606         dev->type            = ARPHRD_AX25;
 607         dev->tx_queue_len    = 10;
 608         dev->hard_header     = ax_header;
 609         dev->rebuild_header  = ax_rebuild_header;
 610
 611         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
 612         memcpy(dev->dev_addr,  ax25_test,  AX25_ADDR_LEN);
 613
 614         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
 615 }
 616
 617 /*
 618  * We have a potential race on dereferencing tty->disc_data, because the tty
 619  * layer provides no locking at all - thus one cpu could be running
 620  * sixpack_receive_buf while another calls sixpack_close, which zeroes
 621  * tty->disc_data and frees the memory that sixpack_receive_buf is using.  The
 622  * best way to fix this is to use a rwlock in the tty struct, but for now we
 623  * use a single global rwlock for all ttys in ppp line discipline.
 624  */
 625 static rwlock_t disc_data_lock = RW_LOCK_UNLOCKED;
 626
 627 static struct mkiss *mkiss_get(struct tty_struct *tty)
 628 {
 629         struct mkiss *ax;
 630
 631         read_lock(&disc_data_lock);
 632         ax = tty->disc_data;
 633         if (ax)
 634                 atomic_inc(&ax->refcnt);
 635         read_unlock(&disc_data_lock);
 636
 637         return ax;
 638 }
 639
 640 static void mkiss_put(struct mkiss *ax)
 641 {
 642         if (atomic_dec_and_test(&ax->refcnt))
 643                 up(&ax->dead_sem);
 644 }
 645
 646 static int mkiss_open(struct tty_struct *tty)
 647 {
 648         struct net_device *dev;
 649         struct mkiss *ax;
 650         int err;
 651
 652         if (!capable(CAP_NET_ADMIN))
 653                 return -EPERM;
 654
 655         dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup);
 656         if (!dev) {
 657                 err = -ENOMEM;
 658                 goto out;
 659         }
 660
 661         ax = netdev_priv(dev);
 662         ax->dev = dev;
 663
 664         spin_lock_init(&ax->buflock);
 665         atomic_set(&ax->refcnt, 1);
 666         init_MUTEX_LOCKED(&ax->dead_sem);
 667
 668         ax->tty = tty;
 669         tty->disc_data = ax;
 670
 671         if (tty->driver->flush_buffer)
 672                 tty->driver->flush_buffer(tty);
 673
 674         /* Restore default settings */
 675         dev->type = ARPHRD_AX25;
 676
 677         /* Perform the low-level AX25 initialization. */
 678         if ((err = ax_open(ax->dev))) {
 679                 goto out_free_netdev;
 680         }
 681
 682         if (register_netdev(dev))
 683                 goto out_free_buffers;
 684
 685         netif_start_queue(dev);
 686
 687         /* Done.  We have linked the TTY line to a channel. */
 688         return 0;
 689
 690 out_free_buffers:
 691         kfree(ax->rbuff);
 692         kfree(ax->xbuff);
 693
 694 out_free_netdev:
 695         free_netdev(dev);
 696
 697 out:
 698         return err;
 699 }
 700
 701 static void mkiss_close(struct tty_struct *tty)
 702 {
 703         struct mkiss *ax;
 704
 705         write_lock(&disc_data_lock);
 706         ax = tty->disc_data;
 707         tty->disc_data = NULL;
 708         write_unlock(&disc_data_lock);
 709
 710         if (ax == 0)
 711                 return;
 712
 713         /*
 714          * We have now ensured that nobody can start using ap from now on, but
 715          * we have to wait for all existing users to finish.
 716          */
 717         if (!atomic_dec_and_test(&ax->refcnt))
 718                 down(&ax->dead_sem);
 719
 720         unregister_netdev(ax->dev);
 721
 722         /* Free all AX25 frame buffers. */
 723         kfree(ax->rbuff);
 724         kfree(ax->xbuff);
 725
 726         ax->tty = NULL;
 727 }
 728
 729 /* Perform I/O control on an active ax25 channel. */
 730 static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
 731         unsigned int cmd, unsigned long arg)
 732 {
 733         struct mkiss *ax = mkiss_get(tty);
 734         struct net_device *dev = ax->dev;
 735         unsigned int tmp, err;
 736
 737         /* First make sure we're connected. */
 738         if (ax == NULL)
 739                 return -ENXIO;
 740
 741         switch (cmd) {
 742         case SIOCGIFNAME:
 743                 err = copy_to_user((void __user *) arg, ax->dev->name,
 744                                    strlen(ax->dev->name) + 1) ? -EFAULT : 0;
 745                 break;
 746
 747         case SIOCGIFENCAP:
 748                 err = put_user(4, (int __user *) arg);
 749                 break;
 750
 751         case SIOCSIFENCAP:
 752                 if (get_user(tmp, (int __user *) arg)) {
 753                         err = -EFAULT;
 754                         break;
 755                 }
 756
 757                 ax->mode = tmp;
 758                 dev->addr_len        = AX25_ADDR_LEN;
 759                 dev->hard_header_len = AX25_KISS_HEADER_LEN +
 760                                        AX25_MAX_HEADER_LEN + 3;
 761                 dev->type            = ARPHRD_AX25;
 762
 763                 err = 0;
 764                 break;
 765
 766         case SIOCSIFHWADDR: {
 767                 char addr[AX25_ADDR_LEN];
 768 printk(KERN_INFO "In SIOCSIFHWADDR");
 769
 770                 if (copy_from_user(&addr,
 771                                    (void __user *) arg, AX25_ADDR_LEN)) {
 772                         err = -EFAULT;
 773                         break;
 774                 }
 775
 776                 spin_lock_irq(&dev->xmit_lock);
 777                 memcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
 778                 spin_unlock_irq(&dev->xmit_lock);
 779
 780                 err = 0;
 781                 break;
 782         }
 783         default:
 784                 err = -ENOIOCTLCMD;
 785         }
 786
 787         mkiss_put(ax);
 788
 789         return err;
 790 }
 791
 792 /*
 793  * Handle the 'receiver data ready' interrupt.
 794  * This function is called by the 'tty_io' module in the kernel when
 795  * a block of data has been received, which can now be decapsulated
 796  * and sent on to the AX.25 layer for further processing.
 797  */
 798 static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 799         char *fp, int count)
 800 {
 801         struct mkiss *ax = mkiss_get(tty);
 802
 803         if (!ax)
 804                 return;
 805
 806         /*
 807          * Argh! mtu change time! - costs us the packet part received
 808          * at the change
 809          */
 810         if (ax->mtu != ax->dev->mtu + 73)
 811                 ax_changedmtu(ax);
 812
 813         /* Read the characters out of the buffer */
 814         while (count--) {
 815                 if (fp != NULL && *fp++) {
 816                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
 817                                 ax->stats.rx_errors++;
 818                         cp++;
 819                         continue;
 820                 }
 821
 822                 kiss_unesc(ax, *cp++);
 823         }
 824
 825         mkiss_put(ax);
 826         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
 827             && tty->driver->unthrottle)
 828                 tty->driver->unthrottle(tty);
 829 }
 830
 831 static int mkiss_receive_room(struct tty_struct *tty)
 832 {
 833         return 65536;  /* We can handle an infinite amount of data. :-) */
 834 }
 835
 836 /*
 837  * Called by the driver when there's room for more data.  If we have
 838  * more packets to send, we send them here.
 839  */
 840 static void mkiss_write_wakeup(struct tty_struct *tty)
 841 {
 842         struct mkiss *ax = mkiss_get(tty);
 843         int actual;
 844
 845         if (!ax)
 846                 return;
 847
 848         if (ax->xleft <= 0)  {
 849                 /* Now serial buffer is almost free & we can start
 850                  * transmission of another packet
 851                  */
 852                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 853
 854                 netif_wake_queue(ax->dev);
 855                 goto out;
 856         }
 857
 858         actual = tty->driver->write(tty, ax->xhead, ax->xleft);
 859         ax->xleft -= actual;
 860         ax->xhead += actual;
 861
 862 out:
 863         mkiss_put(ax);
 864 }
 865
 866 static struct tty_ldisc ax_ldisc = {
 867         .magic          = TTY_LDISC_MAGIC,
 868         .name           = "mkiss",
 869         .open           = mkiss_open,
 870         .close          = mkiss_close,
 871         .ioctl          = mkiss_ioctl,
 872         .receive_buf    = mkiss_receive_buf,
 873         .receive_room   = mkiss_receive_room,
 874         .write_wakeup   = mkiss_write_wakeup
 875 };
 876
 877 static char banner[] __initdata = KERN_INFO \
 878         "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
 879 static char msg_regfail[] __initdata = KERN_ERR \
 880         "mkiss: can't register line discipline (err = %d)\n";
 881
 882 static int __init mkiss_init_driver(void)
 883 {
 884         int status;
 885
 886         printk(banner);
 887
 888         if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0)
 889                 printk(msg_regfail);
 890
 891         return status;
 892 }
 893
 894 static const char msg_unregfail[] __exitdata = KERN_ERR \
 895         "mkiss: can't unregister line discipline (err = %d)\n";
 896
 897 static void __exit mkiss_exit_driver(void)
 898 {
 899         int ret;
 900
 901         if ((ret = tty_unregister_ldisc(N_AX25)))
 902                 printk(msg_unregfail, ret);
 903 }
 904
 905 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
 906 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
 907 MODULE_LICENSE("GPL");
 908 MODULE_ALIAS_LDISC(N_AX25);
 909
 910 module_init(mkiss_init_driver);
 911 module_exit(mkiss_exit_driver);