drivers/net/hamradio/6pack.c

   1 /*
   2  * 6pack.c      This module implements the 6pack protocol for kernel-based
   3  *              devices like TTY. It interfaces between a raw TTY and the
   4  *              kernel's AX.25 protocol layers.
   5  *
   6  * Authors:     Andreas Könsgen <ajk@iehk.rwth-aachen.de>
   7  *              Ralf Baechle DL5RB <ralf@linux-mips.org>
   8  *
   9  * Quite a lot of stuff "stolen" by Joerg Reuter from slip.c, written by
  10  *
  11  *              Laurence Culhane, <loz@holmes.demon.co.uk>
  12  *              Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  13  */
  14
  15 #include <linux/module.h>
  16 #include <asm/system.h>
  17 #include <asm/uaccess.h>
  18 #include <linux/bitops.h>
  19 #include <linux/string.h>
  20 #include <linux/mm.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/in.h>
  23 #include <linux/tty.h>
  24 #include <linux/errno.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/timer.h>
  27 #include <net/ax25.h>
  28 #include <linux/etherdevice.h>
  29 #include <linux/skbuff.h>
  30 #include <linux/rtnetlink.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/if_arp.h>
  33 #include <linux/init.h>
  34 #include <linux/ip.h>
  35 #include <linux/tcp.h>
  36 #include <asm/semaphore.h>
  37 #include <asm/atomic.h>
  38
  39 #define SIXPACK_VERSION    "Revision: 0.3.0"
  40
  41 /* sixpack priority commands */
  42 #define SIXP_SEOF               0x40    /* start and end of a 6pack frame */
  43 #define SIXP_TX_URUN            0x48    /* transmit overrun */
  44 #define SIXP_RX_ORUN            0x50    /* receive overrun */
  45 #define SIXP_RX_BUF_OVL         0x58    /* receive buffer overflow */
  46
  47 #define SIXP_CHKSUM             0xFF    /* valid checksum of a 6pack frame */
  48
  49 /* masks to get certain bits out of the status bytes sent by the TNC */
  50
  51 #define SIXP_CMD_MASK           0xC0
  52 #define SIXP_CHN_MASK           0x07
  53 #define SIXP_PRIO_CMD_MASK      0x80
  54 #define SIXP_STD_CMD_MASK       0x40
  55 #define SIXP_PRIO_DATA_MASK     0x38
  56 #define SIXP_TX_MASK            0x20
  57 #define SIXP_RX_MASK            0x10
  58 #define SIXP_RX_DCD_MASK        0x18
  59 #define SIXP_LEDS_ON            0x78
  60 #define SIXP_LEDS_OFF           0x60
  61 #define SIXP_CON                0x08
  62 #define SIXP_STA                0x10
  63
  64 #define SIXP_FOUND_TNC          0xe9
  65 #define SIXP_CON_ON             0x68
  66 #define SIXP_DCD_MASK           0x08
  67 #define SIXP_DAMA_OFF           0
  68
  69 /* default level 2 parameters */
  70 #define SIXP_TXDELAY                    (HZ/4)  /* in 1 s */
  71 #define SIXP_PERSIST                    50      /* in 256ths */
  72 #define SIXP_SLOTTIME                   (HZ/10) /* in 1 s */
  73 #define SIXP_INIT_RESYNC_TIMEOUT        (3*HZ/2) /* in 1 s */
  74 #define SIXP_RESYNC_TIMEOUT             5*HZ    /* in 1 s */
  75
  76 /* 6pack configuration. */
  77 #define SIXP_NRUNIT                     31      /* MAX number of 6pack channels */
  78 #define SIXP_MTU                        256     /* Default MTU */
  79
  80 enum sixpack_flags {
  81         SIXPF_ERROR,    /* Parity, etc. error   */
  82 };
  83
  84 struct sixpack {
  85         /* Various fields. */
  86         struct tty_struct       *tty;           /* ptr to TTY structure */
  87         struct net_device       *dev;           /* easy for intr handling  */
  88
  89         /* These are pointers to the malloc()ed frame buffers. */
  90         unsigned char           *rbuff;         /* receiver buffer      */
  91         int                     rcount;         /* received chars counter  */
  92         unsigned char           *xbuff;         /* transmitter buffer   */
  93         unsigned char           *xhead;         /* next byte to XMIT */
  94         int                     xleft;          /* bytes left in XMIT queue  */
  95
  96         unsigned char           raw_buf[4];
  97         unsigned char           cooked_buf[400];
  98
  99         unsigned int            rx_count;
 100         unsigned int            rx_count_cooked;
 101
 102         /* 6pack interface statistics. */
 103         struct net_device_stats stats;
 104
 105         int                     mtu;            /* Our mtu (to spot changes!) */
 106         int                     buffsize;       /* Max buffers sizes */
 107
 108         unsigned long           flags;          /* Flag values/ mode etc */
 109         unsigned char           mode;           /* 6pack mode */
 110
 111         /* 6pack stuff */
 112         unsigned char           tx_delay;
 113         unsigned char           persistence;
 114         unsigned char           slottime;
 115         unsigned char           duplex;
 116         unsigned char           led_state;
 117         unsigned char           status;
 118         unsigned char           status1;
 119         unsigned char           status2;
 120         unsigned char           tx_enable;
 121         unsigned char           tnc_state;
 122
 123         struct timer_list       tx_t;
 124         struct timer_list       resync_t;
 125         atomic_t                refcnt;
 126         struct semaphore        dead_sem;
 127         spinlock_t              lock;
 128 };
 129
 130 #define AX25_6PACK_HEADER_LEN 0
 131
 132 static void sixpack_decode(struct sixpack *, unsigned char[], int);
 133 static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
 134
 135 /*
 136  * Perform the persistence/slottime algorithm for CSMA access. If the
 137  * persistence check was successful, write the data to the serial driver.
 138  * Note that in case of DAMA operation, the data is not sent here.
 139  */
 140
 141 static void sp_xmit_on_air(unsigned long channel)
 142 {
 143         struct sixpack *sp = (struct sixpack *) channel;
 144         int actual, when = sp->slottime;
 145         static unsigned char random;
 146
 147         random = random * 17 + 41;
 148
 149         if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
 150                 sp->led_state = 0x70;
 151                 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 152                 sp->tx_enable = 1;
 153                 actual = sp->tty->driver->write(sp->tty, sp->xbuff, sp->status2);
 154                 sp->xleft -= actual;
 155                 sp->xhead += actual;
 156                 sp->led_state = 0x60;
 157                 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 158                 sp->status2 = 0;
 159         } else
 160                 mod_timer(&sp->tx_t, jiffies + ((when + 1) * HZ) / 100);
 161 }
 162
 163 /* ----> 6pack timer interrupt handler and friends. <---- */
 164
 165 /* Encapsulate one AX.25 frame and stuff into a TTY queue. */
 166 static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
 167 {
 168         unsigned char *msg, *p = icp;
 169         int actual, count;
 170
 171         if (len > sp->mtu) {    /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
 172                 msg = "oversized transmit packet!";
 173                 goto out_drop;
 174         }
 175
 176         if (len > sp->mtu) {    /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
 177                 msg = "oversized transmit packet!";
 178                 goto out_drop;
 179         }
 180
 181         if (p[0] > 5) {
 182                 msg = "invalid KISS command";
 183                 goto out_drop;
 184         }
 185
 186         if ((p[0] != 0) && (len > 2)) {
 187                 msg = "KISS control packet too long";
 188                 goto out_drop;
 189         }
 190
 191         if ((p[0] == 0) && (len < 15)) {
 192                 msg = "bad AX.25 packet to transmit";
 193                 goto out_drop;
 194         }
 195
 196         count = encode_sixpack(p, sp->xbuff, len, sp->tx_delay);
 197         set_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
 198
 199         switch (p[0]) {
 200         case 1: sp->tx_delay = p[1];
 201                 return;
 202         case 2: sp->persistence = p[1];
 203                 return;
 204         case 3: sp->slottime = p[1];
 205                 return;
 206         case 4: /* ignored */
 207                 return;
 208         case 5: sp->duplex = p[1];
 209                 return;
 210         }
 211
 212         if (p[0] != 0)
 213                 return;
 214
 215         /*
 216          * In case of fullduplex or DAMA operation, we don't take care about the
 217          * state of the DCD or of any timers, as the determination of the
 218          * correct time to send is the job of the AX.25 layer. We send
 219          * immediately after data has arrived.
 220          */
 221         if (sp->duplex == 1) {
 222                 sp->led_state = 0x70;
 223                 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 224                 sp->tx_enable = 1;
 225                 actual = sp->tty->driver->write(sp->tty, sp->xbuff, count);
 226                 sp->xleft = count - actual;
 227                 sp->xhead = sp->xbuff + actual;
 228                 sp->led_state = 0x60;
 229                 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 230         } else {
 231                 sp->xleft = count;
 232                 sp->xhead = sp->xbuff;
 233                 sp->status2 = count;
 234                 sp_xmit_on_air((unsigned long)sp);
 235         }
 236
 237         return;
 238
 239 out_drop:
 240         sp->stats.tx_dropped++;
 241         netif_start_queue(sp->dev);
 242         if (net_ratelimit())
 243                 printk(KERN_DEBUG "%s: %s - dropped.\n", sp->dev->name, msg);
 244 }
 245
 246 /* Encapsulate an IP datagram and kick it into a TTY queue. */
 247
 248 static int sp_xmit(struct sk_buff *skb, struct net_device *dev)
 249 {
 250         struct sixpack *sp = netdev_priv(dev);
 251
 252         spin_lock_bh(&sp->lock);
 253         /* We were not busy, so we are now... :-) */
 254         netif_stop_queue(dev);
 255         sp->stats.tx_bytes += skb->len;
 256         sp_encaps(sp, skb->data, skb->len);
 257         spin_unlock_bh(&sp->lock);
 258
 259         dev_kfree_skb(skb);
 260
 261         return 0;
 262 }
 263
 264 static int sp_open_dev(struct net_device *dev)
 265 {
 266         struct sixpack *sp = netdev_priv(dev);
 267
 268         if (sp->tty == NULL)
 269                 return -ENODEV;
 270         return 0;
 271 }
 272
 273 /* Close the low-level part of the 6pack channel. */
 274 static int sp_close(struct net_device *dev)
 275 {
 276         struct sixpack *sp = netdev_priv(dev);
 277
 278         spin_lock_bh(&sp->lock);
 279         if (sp->tty) {
 280                 /* TTY discipline is running. */
 281                 clear_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
 282         }
 283         netif_stop_queue(dev);
 284         spin_unlock_bh(&sp->lock);
 285
 286         return 0;
 287 }
 288
 289 /* Return the frame type ID */
 290 static int sp_header(struct sk_buff *skb, struct net_device *dev,
 291         unsigned short type, void *daddr, void *saddr, unsigned len)
 292 {
 293 #ifdef CONFIG_INET
 294         if (type != htons(ETH_P_AX25))
 295                 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
 296 #endif
 297         return 0;
 298 }
 299
 300 static struct net_device_stats *sp_get_stats(struct net_device *dev)
 301 {
 302         struct sixpack *sp = netdev_priv(dev);
 303         return &sp->stats;
 304 }
 305
 306 static int sp_set_mac_address(struct net_device *dev, void *addr)
 307 {
 308         struct sockaddr_ax25 *sa = addr;
 309
 310         netif_tx_lock_bh(dev);
 311         memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
 312         netif_tx_unlock_bh(dev);
 313
 314         return 0;
 315 }
 316
 317 static int sp_rebuild_header(struct sk_buff *skb)
 318 {
 319 #ifdef CONFIG_INET
 320         return ax25_rebuild_header(skb);
 321 #else
 322         return 0;
 323 #endif
 324 }
 325
 326 static void sp_setup(struct net_device *dev)
 327 {
 328         /* Finish setting up the DEVICE info. */
 329         dev->mtu                = SIXP_MTU;
 330         dev->hard_start_xmit    = sp_xmit;
 331         dev->open               = sp_open_dev;
 332         dev->destructor         = free_netdev;
 333         dev->stop               = sp_close;
 334         dev->hard_header        = sp_header;
 335         dev->get_stats          = sp_get_stats;
 336         dev->set_mac_address    = sp_set_mac_address;
 337         dev->hard_header_len    = AX25_MAX_HEADER_LEN;
 338         dev->addr_len           = AX25_ADDR_LEN;
 339         dev->type               = ARPHRD_AX25;
 340         dev->tx_queue_len       = 10;
 341         dev->rebuild_header     = sp_rebuild_header;
 342         dev->tx_timeout         = NULL;
 343
 344         /* Only activated in AX.25 mode */
 345         memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
 346         memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
 347
 348         SET_MODULE_OWNER(dev);
 349
 350         dev->flags              = 0;
 351 }
 352
 353 /* Send one completely decapsulated IP datagram to the IP layer. */
 354
 355 /*
 356  * This is the routine that sends the received data to the kernel AX.25.
 357  * 'cmd' is the KISS command. For AX.25 data, it is zero.
 358  */
 359
 360 static void sp_bump(struct sixpack *sp, char cmd)
 361 {
 362         struct sk_buff *skb;
 363         int count;
 364         unsigned char *ptr;
 365
 366         count = sp->rcount + 1;
 367
 368         sp->stats.rx_bytes += count;
 369
 370         if ((skb = dev_alloc_skb(count)) == NULL)
 371                 goto out_mem;
 372
 373         ptr = skb_put(skb, count);
 374         *ptr++ = cmd;   /* KISS command */
 375
 376         memcpy(ptr, sp->cooked_buf + 1, count);
 377         skb->protocol = ax25_type_trans(skb, sp->dev);
 378         netif_rx(skb);
 379         sp->dev->last_rx = jiffies;
 380         sp->stats.rx_packets++;
 381
 382         return;
 383
 384 out_mem:
 385         sp->stats.rx_dropped++;
 386 }
 387
 388
 389 /* ----------------------------------------------------------------------- */
 390
 391 /*
 392  * We have a potential race on dereferencing tty->disc_data, because the tty
 393  * layer provides no locking at all - thus one cpu could be running
 394  * sixpack_receive_buf while another calls sixpack_close, which zeroes
 395  * tty->disc_data and frees the memory that sixpack_receive_buf is using.  The
 396  * best way to fix this is to use a rwlock in the tty struct, but for now we
 397  * use a single global rwlock for all ttys in ppp line discipline.
 398  */
 399 static DEFINE_RWLOCK(disc_data_lock);
 400
 401 static struct sixpack *sp_get(struct tty_struct *tty)
 402 {
 403         struct sixpack *sp;
 404
 405         read_lock(&disc_data_lock);
 406         sp = tty->disc_data;
 407         if (sp)
 408                 atomic_inc(&sp->refcnt);
 409         read_unlock(&disc_data_lock);
 410
 411         return sp;
 412 }
 413
 414 static void sp_put(struct sixpack *sp)
 415 {
 416         if (atomic_dec_and_test(&sp->refcnt))
 417                 up(&sp->dead_sem);
 418 }
 419
 420 /*
 421  * Called by the TTY driver when there's room for more data.  If we have
 422  * more packets to send, we send them here.
 423  */
 424 static void sixpack_write_wakeup(struct tty_struct *tty)
 425 {
 426         struct sixpack *sp = sp_get(tty);
 427         int actual;
 428
 429         if (!sp)
 430                 return;
 431         if (sp->xleft <= 0)  {
 432                 /* Now serial buffer is almost free & we can start
 433                  * transmission of another packet */
 434                 sp->stats.tx_packets++;
 435                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 436                 sp->tx_enable = 0;
 437                 netif_wake_queue(sp->dev);
 438                 goto out;
 439         }
 440
 441         if (sp->tx_enable) {
 442                 actual = tty->driver->write(tty, sp->xhead, sp->xleft);
 443                 sp->xleft -= actual;
 444                 sp->xhead += actual;
 445         }
 446
 447 out:
 448         sp_put(sp);
 449 }
 450
 451 /* ----------------------------------------------------------------------- */
 452
 453 /*
 454  * Handle the 'receiver data ready' interrupt.
 455  * This function is called by the 'tty_io' module in the kernel when
 456  * a block of 6pack data has been received, which can now be decapsulated
 457  * and sent on to some IP layer for further processing.
 458  */
 459 static void sixpack_receive_buf(struct tty_struct *tty,
 460         const unsigned char *cp, char *fp, int count)
 461 {
 462         struct sixpack *sp;
 463         unsigned char buf[512];
 464         int count1;
 465
 466         if (!count)
 467                 return;
 468
 469         sp = sp_get(tty);
 470         if (!sp)
 471                 return;
 472
 473         memcpy(buf, cp, count < sizeof(buf) ? count : sizeof(buf));
 474
 475         /* Read the characters out of the buffer */
 476
 477         count1 = count;
 478         while (count) {
 479                 count--;
 480                 if (fp && *fp++) {
 481                         if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
 482                                 sp->stats.rx_errors++;
 483                         continue;
 484                 }
 485         }
 486         sixpack_decode(sp, buf, count1);
 487
 488         sp_put(sp);
 489         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
 490             && tty->driver->unthrottle)
 491                 tty->driver->unthrottle(tty);
 492 }
 493
 494 /*
 495  * Try to resync the TNC. Called by the resync timer defined in
 496  * decode_prio_command
 497  */
 498
 499 #define TNC_UNINITIALIZED       0
 500 #define TNC_UNSYNC_STARTUP      1
 501 #define TNC_UNSYNCED            2
 502 #define TNC_IN_SYNC             3
 503
 504 static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
 505 {
 506         char *msg;
 507
 508         switch (new_tnc_state) {
 509         default:                        /* gcc oh piece-o-crap ... */
 510         case TNC_UNSYNC_STARTUP:
 511                 msg = "Synchronizing with TNC";
 512                 break;
 513         case TNC_UNSYNCED:
 514                 msg = "Lost synchronization with TNC\n";
 515                 break;
 516         case TNC_IN_SYNC:
 517                 msg = "Found TNC";
 518                 break;
 519         }
 520
 521         sp->tnc_state = new_tnc_state;
 522         printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
 523 }
 524
 525 static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
 526 {
 527         int old_tnc_state = sp->tnc_state;
 528
 529         if (old_tnc_state != new_tnc_state)
 530                 __tnc_set_sync_state(sp, new_tnc_state);
 531 }
 532
 533 static void resync_tnc(unsigned long channel)
 534 {
 535         struct sixpack *sp = (struct sixpack *) channel;
 536         static char resync_cmd = 0xe8;
 537
 538         /* clear any data that might have been received */
 539
 540         sp->rx_count = 0;
 541         sp->rx_count_cooked = 0;
 542
 543         /* reset state machine */
 544
 545         sp->status = 1;
 546         sp->status1 = 1;
 547         sp->status2 = 0;
 548
 549         /* resync the TNC */
 550
 551         sp->led_state = 0x60;
 552         sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 553         sp->tty->driver->write(sp->tty, &resync_cmd, 1);
 554
 555
 556         /* Start resync timer again -- the TNC might be still absent */
 557
 558         del_timer(&sp->resync_t);
 559         sp->resync_t.data       = (unsigned long) sp;
 560         sp->resync_t.function   = resync_tnc;
 561         sp->resync_t.expires    = jiffies + SIXP_RESYNC_TIMEOUT;
 562         add_timer(&sp->resync_t);
 563 }
 564
 565 static inline int tnc_init(struct sixpack *sp)
 566 {
 567         unsigned char inbyte = 0xe8;
 568
 569         tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
 570
 571         sp->tty->driver->write(sp->tty, &inbyte, 1);
 572
 573         del_timer(&sp->resync_t);
 574         sp->resync_t.data = (unsigned long) sp;
 575         sp->resync_t.function = resync_tnc;
 576         sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
 577         add_timer(&sp->resync_t);
 578
 579         return 0;
 580 }
 581
 582 /*
 583  * Open the high-level part of the 6pack channel.
 584  * This function is called by the TTY module when the
 585  * 6pack line discipline is called for.  Because we are
 586  * sure the tty line exists, we only have to link it to
 587  * a free 6pcack channel...
 588  */
 589 static int sixpack_open(struct tty_struct *tty)
 590 {
 591         char *rbuff = NULL, *xbuff = NULL;
 592         struct net_device *dev;
 593         struct sixpack *sp;
 594         unsigned long len;
 595         int err = 0;
 596
 597         if (!capable(CAP_NET_ADMIN))
 598                 return -EPERM;
 599
 600         dev = alloc_netdev(sizeof(struct sixpack), "sp%d", sp_setup);
 601         if (!dev) {
 602                 err = -ENOMEM;
 603                 goto out;
 604         }
 605
 606         sp = netdev_priv(dev);
 607         sp->dev = dev;
 608
 609         spin_lock_init(&sp->lock);
 610         atomic_set(&sp->refcnt, 1);
 611         init_MUTEX_LOCKED(&sp->dead_sem);
 612
 613         /* !!! length of the buffers. MTU is IP MTU, not PACLEN!  */
 614
 615         len = dev->mtu * 2;
 616
 617         rbuff = kmalloc(len + 4, GFP_KERNEL);
 618         xbuff = kmalloc(len + 4, GFP_KERNEL);
 619
 620         if (rbuff == NULL || xbuff == NULL) {
 621                 err = -ENOBUFS;
 622                 goto out_free;
 623         }
 624
 625         spin_lock_bh(&sp->lock);
 626
 627         sp->tty = tty;
 628
 629         sp->rbuff       = rbuff;
 630         sp->xbuff       = xbuff;
 631
 632         sp->mtu         = AX25_MTU + 73;
 633         sp->buffsize    = len;
 634         sp->rcount      = 0;
 635         sp->rx_count    = 0;
 636         sp->rx_count_cooked = 0;
 637         sp->xleft       = 0;
 638
 639         sp->flags       = 0;            /* Clear ESCAPE & ERROR flags */
 640
 641         sp->duplex      = 0;
 642         sp->tx_delay    = SIXP_TXDELAY;
 643         sp->persistence = SIXP_PERSIST;
 644         sp->slottime    = SIXP_SLOTTIME;
 645         sp->led_state   = 0x60;
 646         sp->status      = 1;
 647         sp->status1     = 1;
 648         sp->status2     = 0;
 649         sp->tx_enable   = 0;
 650
 651         netif_start_queue(dev);
 652
 653         init_timer(&sp->tx_t);
 654         sp->tx_t.function = sp_xmit_on_air;
 655         sp->tx_t.data = (unsigned long) sp;
 656
 657         init_timer(&sp->resync_t);
 658
 659         spin_unlock_bh(&sp->lock);
 660
 661         /* Done.  We have linked the TTY line to a channel. */
 662         tty->disc_data = sp;
 663         tty->receive_room = 65536;
 664
 665         /* Now we're ready to register. */
 666         if (register_netdev(dev))
 667                 goto out_free;
 668
 669         tnc_init(sp);
 670
 671         return 0;
 672
 673 out_free:
 674         kfree(xbuff);
 675         kfree(rbuff);
 676
 677         if (dev)
 678                 free_netdev(dev);
 679
 680 out:
 681         return err;
 682 }
 683
 684
 685 /*
 686  * Close down a 6pack channel.
 687  * This means flushing out any pending queues, and then restoring the
 688  * TTY line discipline to what it was before it got hooked to 6pack
 689  * (which usually is TTY again).
 690  */
 691 static void sixpack_close(struct tty_struct *tty)
 692 {
 693         struct sixpack *sp;
 694
 695         write_lock(&disc_data_lock);
 696         sp = tty->disc_data;
 697         tty->disc_data = NULL;
 698         write_unlock(&disc_data_lock);
 699         if (sp == 0)
 700                 return;
 701
 702         /*
 703          * We have now ensured that nobody can start using ap from now on, but
 704          * we have to wait for all existing users to finish.
 705          */
 706         if (!atomic_dec_and_test(&sp->refcnt))
 707                 down(&sp->dead_sem);
 708
 709         unregister_netdev(sp->dev);
 710
 711         del_timer(&sp->tx_t);
 712         del_timer(&sp->resync_t);
 713
 714         /* Free all 6pack frame buffers. */
 715         kfree(sp->rbuff);
 716         kfree(sp->xbuff);
 717 }
 718
 719 /* Perform I/O control on an active 6pack channel. */
 720 static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
 721         unsigned int cmd, unsigned long arg)
 722 {
 723         struct sixpack *sp = sp_get(tty);
 724         struct net_device *dev = sp->dev;
 725         unsigned int tmp, err;
 726
 727         if (!sp)
 728                 return -ENXIO;
 729
 730         switch(cmd) {
 731         case SIOCGIFNAME:
 732                 err = copy_to_user((void __user *) arg, dev->name,
 733                                    strlen(dev->name) + 1) ? -EFAULT : 0;
 734                 break;
 735
 736         case SIOCGIFENCAP:
 737                 err = put_user(0, (int __user *) arg);
 738                 break;
 739
 740         case SIOCSIFENCAP:
 741                 if (get_user(tmp, (int __user *) arg)) {
 742                         err = -EFAULT;
 743                         break;
 744                 }
 745
 746                 sp->mode = tmp;
 747                 dev->addr_len        = AX25_ADDR_LEN;
 748                 dev->hard_header_len = AX25_KISS_HEADER_LEN +
 749                                        AX25_MAX_HEADER_LEN + 3;
 750                 dev->type            = ARPHRD_AX25;
 751
 752                 err = 0;
 753                 break;
 754
 755          case SIOCSIFHWADDR: {
 756                 char addr[AX25_ADDR_LEN];
 757
 758                 if (copy_from_user(&addr,
 759                                    (void __user *) arg, AX25_ADDR_LEN)) {
 760                         err = -EFAULT;
 761                         break;
 762                 }
 763
 764                 netif_tx_lock_bh(dev);
 765                 memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
 766                 netif_tx_unlock_bh(dev);
 767
 768                 err = 0;
 769                 break;
 770         }
 771
 772         /* Allow stty to read, but not set, the serial port */
 773         case TCGETS:
 774         case TCGETA:
 775                 err = n_tty_ioctl(tty, (struct file *) file, cmd, arg);
 776                 break;
 777
 778         default:
 779                 err = -ENOIOCTLCMD;
 780         }
 781
 782         sp_put(sp);
 783
 784         return err;
 785 }
 786
 787 static struct tty_ldisc sp_ldisc = {
 788         .owner          = THIS_MODULE,
 789         .magic          = TTY_LDISC_MAGIC,
 790         .name           = "6pack",
 791         .open           = sixpack_open,
 792         .close          = sixpack_close,
 793         .ioctl          = sixpack_ioctl,
 794         .receive_buf    = sixpack_receive_buf,
 795         .write_wakeup   = sixpack_write_wakeup,
 796 };
 797
 798 /* Initialize 6pack control device -- register 6pack line discipline */
 799
 800 static char msg_banner[]  __initdata = KERN_INFO \
 801         "AX.25: 6pack driver, " SIXPACK_VERSION "\n";
 802 static char msg_regfail[] __initdata = KERN_ERR  \
 803         "6pack: can't register line discipline (err = %d)\n";
 804
 805 static int __init sixpack_init_driver(void)
 806 {
 807         int status;
 808
 809         printk(msg_banner);
 810
 811         /* Register the provided line protocol discipline */
 812         if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
 813                 printk(msg_regfail, status);
 814
 815         return status;
 816 }
 817
 818 static const char msg_unregfail[] __exitdata = KERN_ERR \
 819         "6pack: can't unregister line discipline (err = %d)\n";
 820
 821 static void __exit sixpack_exit_driver(void)
 822 {
 823         int ret;
 824
 825         if ((ret = tty_unregister_ldisc(N_6PACK)))
 826                 printk(msg_unregfail, ret);
 827 }
 828
 829 /* encode an AX.25 packet into 6pack */
 830
 831 static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
 832         int length, unsigned char tx_delay)
 833 {
 834         int count = 0;
 835         unsigned char checksum = 0, buf[400];
 836         int raw_count = 0;
 837
 838         tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
 839         tx_buf_raw[raw_count++] = SIXP_SEOF;
 840
 841         buf[0] = tx_delay;
 842         for (count = 1; count < length; count++)
 843                 buf[count] = tx_buf[count];
 844
 845         for (count = 0; count < length; count++)
 846                 checksum += buf[count];
 847         buf[length] = (unsigned char) 0xff - checksum;
 848
 849         for (count = 0; count <= length; count++) {
 850                 if ((count % 3) == 0) {
 851                         tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
 852                         tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
 853                 } else if ((count % 3) == 1) {
 854                         tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
 855                         tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x3c);
 856                 } else {
 857                         tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
 858                         tx_buf_raw[raw_count++] = (buf[count] >> 2);
 859                 }
 860         }
 861         if ((length % 3) != 2)
 862                 raw_count++;
 863         tx_buf_raw[raw_count++] = SIXP_SEOF;
 864         return raw_count;
 865 }
 866
 867 /* decode 4 sixpack-encoded bytes into 3 data bytes */
 868
 869 static void decode_data(struct sixpack *sp, unsigned char inbyte)
 870 {
 871         unsigned char *buf;
 872
 873         if (sp->rx_count != 3) {
 874                 sp->raw_buf[sp->rx_count++] = inbyte;
 875
 876                 return;
 877         }
 878
 879         buf = sp->raw_buf;
 880         sp->cooked_buf[sp->rx_count_cooked++] =
 881                 buf[0] | ((buf[1] << 2) & 0xc0);
 882         sp->cooked_buf[sp->rx_count_cooked++] =
 883                 (buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
 884         sp->cooked_buf[sp->rx_count_cooked++] =
 885                 (buf[2] & 0x03) | (inbyte << 2);
 886         sp->rx_count = 0;
 887 }
 888
 889 /* identify and execute a 6pack priority command byte */
 890
 891 static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
 892 {
 893         unsigned char channel;
 894         int actual;
 895
 896         channel = cmd & SIXP_CHN_MASK;
 897         if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {     /* idle ? */
 898
 899         /* RX and DCD flags can only be set in the same prio command,
 900            if the DCD flag has been set without the RX flag in the previous
 901            prio command. If DCD has not been set before, something in the
 902            transmission has gone wrong. In this case, RX and DCD are
 903            cleared in order to prevent the decode_data routine from
 904            reading further data that might be corrupt. */
 905
 906                 if (((sp->status & SIXP_DCD_MASK) == 0) &&
 907                         ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
 908                                 if (sp->status != 1)
 909                                         printk(KERN_DEBUG "6pack: protocol violation\n");
 910                                 else
 911                                         sp->status = 0;
 912                                 cmd &= ~SIXP_RX_DCD_MASK;
 913                 }
 914                 sp->status = cmd & SIXP_PRIO_DATA_MASK;
 915         } else { /* output watchdog char if idle */
 916                 if ((sp->status2 != 0) && (sp->duplex == 1)) {
 917                         sp->led_state = 0x70;
 918                         sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 919                         sp->tx_enable = 1;
 920                         actual = sp->tty->driver->write(sp->tty, sp->xbuff, sp->status2);
 921                         sp->xleft -= actual;
 922                         sp->xhead += actual;
 923                         sp->led_state = 0x60;
 924                         sp->status2 = 0;
 925
 926                 }
 927         }
 928
 929         /* needed to trigger the TNC watchdog */
 930         sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 931
 932         /* if the state byte has been received, the TNC is present,
 933            so the resync timer can be reset. */
 934
 935         if (sp->tnc_state == TNC_IN_SYNC) {
 936                 del_timer(&sp->resync_t);
 937                 sp->resync_t.data       = (unsigned long) sp;
 938                 sp->resync_t.function   = resync_tnc;
 939                 sp->resync_t.expires    = jiffies + SIXP_INIT_RESYNC_TIMEOUT;
 940                 add_timer(&sp->resync_t);
 941         }
 942
 943         sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
 944 }
 945
 946 /* identify and execute a standard 6pack command byte */
 947
 948 static void decode_std_command(struct sixpack *sp, unsigned char cmd)
 949 {
 950         unsigned char checksum = 0, rest = 0, channel;
 951         short i;
 952
 953         channel = cmd & SIXP_CHN_MASK;
 954         switch (cmd & SIXP_CMD_MASK) {     /* normal command */
 955         case SIXP_SEOF:
 956                 if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
 957                         if ((sp->status & SIXP_RX_DCD_MASK) ==
 958                                 SIXP_RX_DCD_MASK) {
 959                                 sp->led_state = 0x68;
 960                                 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 961                         }
 962                 } else {
 963                         sp->led_state = 0x60;
 964                         /* fill trailing bytes with zeroes */
 965                         sp->tty->driver->write(sp->tty, &sp->led_state, 1);
 966                         rest = sp->rx_count;
 967                         if (rest != 0)
 968                                  for (i = rest; i <= 3; i++)
 969                                         decode_data(sp, 0);
 970                         if (rest == 2)
 971                                 sp->rx_count_cooked -= 2;
 972                         else if (rest == 3)
 973                                 sp->rx_count_cooked -= 1;
 974                         for (i = 0; i < sp->rx_count_cooked; i++)
 975                                 checksum += sp->cooked_buf[i];
 976                         if (checksum != SIXP_CHKSUM) {
 977                                 printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
 978                         } else {
 979                                 sp->rcount = sp->rx_count_cooked-2;
 980                                 sp_bump(sp, 0);
 981                         }
 982                         sp->rx_count_cooked = 0;
 983                 }
 984                 break;
 985         case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
 986                 break;
 987         case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
 988                 break;
 989         case SIXP_RX_BUF_OVL:
 990                 printk(KERN_DEBUG "6pack: RX buffer overflow\n");
 991         }
 992 }
 993
 994 /* decode a 6pack packet */
 995
 996 static void
 997 sixpack_decode(struct sixpack *sp, unsigned char *pre_rbuff, int count)
 998 {
 999         unsigned char inbyte;
1000         int count1;
1001
1002         for (count1 = 0; count1 < count; count1++) {
1003                 inbyte = pre_rbuff[count1];
1004                 if (inbyte == SIXP_FOUND_TNC) {
1005                         tnc_set_sync_state(sp, TNC_IN_SYNC);
1006                         del_timer(&sp->resync_t);
1007                 }
1008                 if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
1009                         decode_prio_command(sp, inbyte);
1010                 else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
1011                         decode_std_command(sp, inbyte);
1012                 else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
1013                         decode_data(sp, inbyte);
1014         }
1015 }
1016
1017 MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
1018 MODULE_DESCRIPTION("6pack driver for AX.25");
1019 MODULE_LICENSE("GPL");
1020 MODULE_ALIAS_LDISC(N_6PACK);
1021
1022 module_init(sixpack_init_driver);
1023 module_exit(sixpack_exit_driver);