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