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 <linux/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->ops->write(sp->tty, &sp->led_state, 1);
 152                 sp->tx_enable = 1;
 153                 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
 154                 sp->xleft -= actual;
 155                 sp->xhead += actual;
 156                 sp->led_state = 0x60;
 157                 sp->tty->ops->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->ops->write(sp->tty, &sp->led_state, 1);
 224                 sp->tx_enable = 1;
 225                 actual = sp->tty->ops->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->ops->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, const void *daddr,
 292                      const void *saddr, unsigned len)
 293 {
 294 #ifdef CONFIG_INET
 295         if (type != ETH_P_AX25)
 296                 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
 297 #endif
 298         return 0;
 299 }
 300
 301 static struct net_device_stats *sp_get_stats(struct net_device *dev)
 302 {
 303         struct sixpack *sp = netdev_priv(dev);
 304         return &sp->stats;
 305 }
 306
 307 static int sp_set_mac_address(struct net_device *dev, void *addr)
 308 {
 309         struct sockaddr_ax25 *sa = addr;
 310
 311         netif_tx_lock_bh(dev);
 312         memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
 313         netif_tx_unlock_bh(dev);
 314
 315         return 0;
 316 }
 317
 318 static int sp_rebuild_header(struct sk_buff *skb)
 319 {
 320 #ifdef CONFIG_INET
 321         return ax25_rebuild_header(skb);
 322 #else
 323         return 0;
 324 #endif
 325 }
 326
 327 static const struct header_ops sp_header_ops = {
 328         .create         = sp_header,
 329         .rebuild        = sp_rebuild_header,
 330 };
 331
 332 static void sp_setup(struct net_device *dev)
 333 {
 334         /* Finish setting up the DEVICE info. */
 335         dev->mtu                = SIXP_MTU;
 336         dev->hard_start_xmit    = sp_xmit;
 337         dev->open               = sp_open_dev;
 338         dev->destructor         = free_netdev;
 339         dev->stop               = sp_close;
 340
 341         dev->get_stats          = sp_get_stats;
 342         dev->set_mac_address    = sp_set_mac_address;
 343         dev->hard_header_len    = AX25_MAX_HEADER_LEN;
 344         dev->header_ops         = &sp_header_ops;
 345
 346         dev->addr_len           = AX25_ADDR_LEN;
 347         dev->type               = ARPHRD_AX25;
 348         dev->tx_queue_len       = 10;
 349         dev->tx_timeout         = NULL;
 350
 351         /* Only activated in AX.25 mode */
 352         memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
 353         memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
 354
 355         dev->flags              = 0;
 356 }
 357
 358 /* Send one completely decapsulated IP datagram to the IP layer. */
 359
 360 /*
 361  * This is the routine that sends the received data to the kernel AX.25.
 362  * 'cmd' is the KISS command. For AX.25 data, it is zero.
 363  */
 364
 365 static void sp_bump(struct sixpack *sp, char cmd)
 366 {
 367         struct sk_buff *skb;
 368         int count;
 369         unsigned char *ptr;
 370
 371         count = sp->rcount + 1;
 372
 373         sp->stats.rx_bytes += count;
 374
 375         if ((skb = dev_alloc_skb(count)) == NULL)
 376                 goto out_mem;
 377
 378         ptr = skb_put(skb, count);
 379         *ptr++ = cmd;   /* KISS command */
 380
 381         memcpy(ptr, sp->cooked_buf + 1, count);
 382         skb->protocol = ax25_type_trans(skb, sp->dev);
 383         netif_rx(skb);
 384         sp->dev->last_rx = jiffies;
 385         sp->stats.rx_packets++;
 386
 387         return;
 388
 389 out_mem:
 390         sp->stats.rx_dropped++;
 391 }
 392
 393
 394 /* ----------------------------------------------------------------------- */
 395
 396 /*
 397  * We have a potential race on dereferencing tty->disc_data, because the tty
 398  * layer provides no locking at all - thus one cpu could be running
 399  * sixpack_receive_buf while another calls sixpack_close, which zeroes
 400  * tty->disc_data and frees the memory that sixpack_receive_buf is using.  The
 401  * best way to fix this is to use a rwlock in the tty struct, but for now we
 402  * use a single global rwlock for all ttys in ppp line discipline.
 403  */
 404 static DEFINE_RWLOCK(disc_data_lock);
 405
 406 static struct sixpack *sp_get(struct tty_struct *tty)
 407 {
 408         struct sixpack *sp;
 409
 410         read_lock(&disc_data_lock);
 411         sp = tty->disc_data;
 412         if (sp)
 413                 atomic_inc(&sp->refcnt);
 414         read_unlock(&disc_data_lock);
 415
 416         return sp;
 417 }
 418
 419 static void sp_put(struct sixpack *sp)
 420 {
 421         if (atomic_dec_and_test(&sp->refcnt))
 422                 up(&sp->dead_sem);
 423 }
 424
 425 /*
 426  * Called by the TTY driver when there's room for more data.  If we have
 427  * more packets to send, we send them here.
 428  */
 429 static void sixpack_write_wakeup(struct tty_struct *tty)
 430 {
 431         struct sixpack *sp = sp_get(tty);
 432         int actual;
 433
 434         if (!sp)
 435                 return;
 436         if (sp->xleft <= 0)  {
 437                 /* Now serial buffer is almost free & we can start
 438                  * transmission of another packet */
 439                 sp->stats.tx_packets++;
 440                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 441                 sp->tx_enable = 0;
 442                 netif_wake_queue(sp->dev);
 443                 goto out;
 444         }
 445
 446         if (sp->tx_enable) {
 447                 actual = tty->ops->write(tty, sp->xhead, sp->xleft);
 448                 sp->xleft -= actual;
 449                 sp->xhead += actual;
 450         }
 451
 452 out:
 453         sp_put(sp);
 454 }
 455
 456 /* ----------------------------------------------------------------------- */
 457
 458 /*
 459  * Handle the 'receiver data ready' interrupt.
 460  * This function is called by the 'tty_io' module in the kernel when
 461  * a block of 6pack data has been received, which can now be decapsulated
 462  * and sent on to some IP layer for further processing.
 463  */
 464 static void sixpack_receive_buf(struct tty_struct *tty,
 465         const unsigned char *cp, char *fp, int count)
 466 {
 467         struct sixpack *sp;
 468         unsigned char buf[512];
 469         int count1;
 470
 471         if (!count)
 472                 return;
 473
 474         sp = sp_get(tty);
 475         if (!sp)
 476                 return;
 477
 478         memcpy(buf, cp, count < sizeof(buf) ? count : sizeof(buf));
 479
 480         /* Read the characters out of the buffer */
 481
 482         count1 = count;
 483         while (count) {
 484                 count--;
 485                 if (fp && *fp++) {
 486                         if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
 487                                 sp->stats.rx_errors++;
 488                         continue;
 489                 }
 490         }
 491         sixpack_decode(sp, buf, count1);
 492
 493         sp_put(sp);
 494         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
 495             && tty->ops->unthrottle)
 496                 tty->ops->unthrottle(tty);
 497 }
 498
 499 /*
 500  * Try to resync the TNC. Called by the resync timer defined in
 501  * decode_prio_command
 502  */
 503
 504 #define TNC_UNINITIALIZED       0
 505 #define TNC_UNSYNC_STARTUP      1
 506 #define TNC_UNSYNCED            2
 507 #define TNC_IN_SYNC             3
 508
 509 static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
 510 {
 511         char *msg;
 512
 513         switch (new_tnc_state) {
 514         default:                        /* gcc oh piece-o-crap ... */
 515         case TNC_UNSYNC_STARTUP:
 516                 msg = "Synchronizing with TNC";
 517                 break;
 518         case TNC_UNSYNCED:
 519                 msg = "Lost synchronization with TNC\n";
 520                 break;
 521         case TNC_IN_SYNC:
 522                 msg = "Found TNC";
 523                 break;
 524         }
 525
 526         sp->tnc_state = new_tnc_state;
 527         printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
 528 }
 529
 530 static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
 531 {
 532         int old_tnc_state = sp->tnc_state;
 533
 534         if (old_tnc_state != new_tnc_state)
 535                 __tnc_set_sync_state(sp, new_tnc_state);
 536 }
 537
 538 static void resync_tnc(unsigned long channel)
 539 {
 540         struct sixpack *sp = (struct sixpack *) channel;
 541         static char resync_cmd = 0xe8;
 542
 543         /* clear any data that might have been received */
 544
 545         sp->rx_count = 0;
 546         sp->rx_count_cooked = 0;
 547
 548         /* reset state machine */
 549
 550         sp->status = 1;
 551         sp->status1 = 1;
 552         sp->status2 = 0;
 553
 554         /* resync the TNC */
 555
 556         sp->led_state = 0x60;
 557         sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 558         sp->tty->ops->write(sp->tty, &resync_cmd, 1);
 559
 560
 561         /* Start resync timer again -- the TNC might be still absent */
 562
 563         del_timer(&sp->resync_t);
 564         sp->resync_t.data       = (unsigned long) sp;
 565         sp->resync_t.function   = resync_tnc;
 566         sp->resync_t.expires    = jiffies + SIXP_RESYNC_TIMEOUT;
 567         add_timer(&sp->resync_t);
 568 }
 569
 570 static inline int tnc_init(struct sixpack *sp)
 571 {
 572         unsigned char inbyte = 0xe8;
 573
 574         tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
 575
 576         sp->tty->ops->write(sp->tty, &inbyte, 1);
 577
 578         del_timer(&sp->resync_t);
 579         sp->resync_t.data = (unsigned long) sp;
 580         sp->resync_t.function = resync_tnc;
 581         sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
 582         add_timer(&sp->resync_t);
 583
 584         return 0;
 585 }
 586
 587 /*
 588  * Open the high-level part of the 6pack channel.
 589  * This function is called by the TTY module when the
 590  * 6pack line discipline is called for.  Because we are
 591  * sure the tty line exists, we only have to link it to
 592  * a free 6pcack channel...
 593  */
 594 static int sixpack_open(struct tty_struct *tty)
 595 {
 596         char *rbuff = NULL, *xbuff = NULL;
 597         struct net_device *dev;
 598         struct sixpack *sp;
 599         unsigned long len;
 600         int err = 0;
 601
 602         if (!capable(CAP_NET_ADMIN))
 603                 return -EPERM;
 604         if (tty->ops->write == NULL)
 605                 return -EOPNOTSUPP;
 606
 607         dev = alloc_netdev(sizeof(struct sixpack), "sp%d", sp_setup);
 608         if (!dev) {
 609                 err = -ENOMEM;
 610                 goto out;
 611         }
 612
 613         sp = netdev_priv(dev);
 614         sp->dev = dev;
 615
 616         spin_lock_init(&sp->lock);
 617         atomic_set(&sp->refcnt, 1);
 618         init_MUTEX_LOCKED(&sp->dead_sem);
 619
 620         /* !!! length of the buffers. MTU is IP MTU, not PACLEN!  */
 621
 622         len = dev->mtu * 2;
 623
 624         rbuff = kmalloc(len + 4, GFP_KERNEL);
 625         xbuff = kmalloc(len + 4, GFP_KERNEL);
 626
 627         if (rbuff == NULL || xbuff == NULL) {
 628                 err = -ENOBUFS;
 629                 goto out_free;
 630         }
 631
 632         spin_lock_bh(&sp->lock);
 633
 634         sp->tty = tty;
 635
 636         sp->rbuff       = rbuff;
 637         sp->xbuff       = xbuff;
 638
 639         sp->mtu         = AX25_MTU + 73;
 640         sp->buffsize    = len;
 641         sp->rcount      = 0;
 642         sp->rx_count    = 0;
 643         sp->rx_count_cooked = 0;
 644         sp->xleft       = 0;
 645
 646         sp->flags       = 0;            /* Clear ESCAPE & ERROR flags */
 647
 648         sp->duplex      = 0;
 649         sp->tx_delay    = SIXP_TXDELAY;
 650         sp->persistence = SIXP_PERSIST;
 651         sp->slottime    = SIXP_SLOTTIME;
 652         sp->led_state   = 0x60;
 653         sp->status      = 1;
 654         sp->status1     = 1;
 655         sp->status2     = 0;
 656         sp->tx_enable   = 0;
 657
 658         netif_start_queue(dev);
 659
 660         init_timer(&sp->tx_t);
 661         sp->tx_t.function = sp_xmit_on_air;
 662         sp->tx_t.data = (unsigned long) sp;
 663
 664         init_timer(&sp->resync_t);
 665
 666         spin_unlock_bh(&sp->lock);
 667
 668         /* Done.  We have linked the TTY line to a channel. */
 669         tty->disc_data = sp;
 670         tty->receive_room = 65536;
 671
 672         /* Now we're ready to register. */
 673         if (register_netdev(dev))
 674                 goto out_free;
 675
 676         tnc_init(sp);
 677
 678         return 0;
 679
 680 out_free:
 681         kfree(xbuff);
 682         kfree(rbuff);
 683
 684         if (dev)
 685                 free_netdev(dev);
 686
 687 out:
 688         return err;
 689 }
 690
 691
 692 /*
 693  * Close down a 6pack channel.
 694  * This means flushing out any pending queues, and then restoring the
 695  * TTY line discipline to what it was before it got hooked to 6pack
 696  * (which usually is TTY again).
 697  */
 698 static void sixpack_close(struct tty_struct *tty)
 699 {
 700         struct sixpack *sp;
 701
 702         write_lock(&disc_data_lock);
 703         sp = tty->disc_data;
 704         tty->disc_data = NULL;
 705         write_unlock(&disc_data_lock);
 706         if (!sp)
 707                 return;
 708
 709         /*
 710          * We have now ensured that nobody can start using ap from now on, but
 711          * we have to wait for all existing users to finish.
 712          */
 713         if (!atomic_dec_and_test(&sp->refcnt))
 714                 down(&sp->dead_sem);
 715
 716         unregister_netdev(sp->dev);
 717
 718         del_timer(&sp->tx_t);
 719         del_timer(&sp->resync_t);
 720
 721         /* Free all 6pack frame buffers. */
 722         kfree(sp->rbuff);
 723         kfree(sp->xbuff);
 724 }
 725
 726 /* Perform I/O control on an active 6pack channel. */
 727 static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
 728         unsigned int cmd, unsigned long arg)
 729 {
 730         struct sixpack *sp = sp_get(tty);
 731         struct net_device *dev = sp->dev;
 732         unsigned int tmp, err;
 733
 734         if (!sp)
 735                 return -ENXIO;
 736
 737         switch(cmd) {
 738         case SIOCGIFNAME:
 739                 err = copy_to_user((void __user *) arg, dev->name,
 740                                    strlen(dev->name) + 1) ? -EFAULT : 0;
 741                 break;
 742
 743         case SIOCGIFENCAP:
 744                 err = put_user(0, (int __user *) arg);
 745                 break;
 746
 747         case SIOCSIFENCAP:
 748                 if (get_user(tmp, (int __user *) arg)) {
 749                         err = -EFAULT;
 750                         break;
 751                 }
 752
 753                 sp->mode = tmp;
 754                 dev->addr_len        = AX25_ADDR_LEN;
 755                 dev->hard_header_len = AX25_KISS_HEADER_LEN +
 756                                        AX25_MAX_HEADER_LEN + 3;
 757                 dev->type            = ARPHRD_AX25;
 758
 759                 err = 0;
 760                 break;
 761
 762          case SIOCSIFHWADDR: {
 763                 char addr[AX25_ADDR_LEN];
 764
 765                 if (copy_from_user(&addr,
 766                                    (void __user *) arg, AX25_ADDR_LEN)) {
 767                                 err = -EFAULT;
 768                                 break;
 769                         }
 770
 771                         netif_tx_lock_bh(dev);
 772                         memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
 773                         netif_tx_unlock_bh(dev);
 774
 775                         err = 0;
 776                         break;
 777                 }
 778
 779         default:
 780                 err = tty_mode_ioctl(tty, file, cmd, arg);
 781         }
 782
 783         sp_put(sp);
 784
 785         return err;
 786 }
 787
 788 static struct tty_ldisc sp_ldisc = {
 789         .owner          = THIS_MODULE,
 790         .magic          = TTY_LDISC_MAGIC,
 791         .name           = "6pack",
 792         .open           = sixpack_open,
 793         .close          = sixpack_close,
 794         .ioctl          = sixpack_ioctl,
 795         .receive_buf    = sixpack_receive_buf,
 796         .write_wakeup   = sixpack_write_wakeup,
 797 };
 798
 799 /* Initialize 6pack control device -- register 6pack line discipline */
 800
 801 static char msg_banner[]  __initdata = KERN_INFO \
 802         "AX.25: 6pack driver, " SIXPACK_VERSION "\n";
 803 static char msg_regfail[] __initdata = KERN_ERR  \
 804         "6pack: can't register line discipline (err = %d)\n";
 805
 806 static int __init sixpack_init_driver(void)
 807 {
 808         int status;
 809
 810         printk(msg_banner);
 811
 812         /* Register the provided line protocol discipline */
 813         if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
 814                 printk(msg_regfail, status);
 815
 816         return status;
 817 }
 818
 819 static const char msg_unregfail[] __exitdata = KERN_ERR \
 820         "6pack: can't unregister line discipline (err = %d)\n";
 821
 822 static void __exit sixpack_exit_driver(void)
 823 {
 824         int ret;
 825
 826         if ((ret = tty_unregister_ldisc(N_6PACK)))
 827                 printk(msg_unregfail, ret);
 828 }
 829
 830 /* encode an AX.25 packet into 6pack */
 831
 832 static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
 833         int length, unsigned char tx_delay)
 834 {
 835         int count = 0;
 836         unsigned char checksum = 0, buf[400];
 837         int raw_count = 0;
 838
 839         tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
 840         tx_buf_raw[raw_count++] = SIXP_SEOF;
 841
 842         buf[0] = tx_delay;
 843         for (count = 1; count < length; count++)
 844                 buf[count] = tx_buf[count];
 845
 846         for (count = 0; count < length; count++)
 847                 checksum += buf[count];
 848         buf[length] = (unsigned char) 0xff - checksum;
 849
 850         for (count = 0; count <= length; count++) {
 851                 if ((count % 3) == 0) {
 852                         tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
 853                         tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
 854                 } else if ((count % 3) == 1) {
 855                         tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
 856                         tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x3c);
 857                 } else {
 858                         tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
 859                         tx_buf_raw[raw_count++] = (buf[count] >> 2);
 860                 }
 861         }
 862         if ((length % 3) != 2)
 863                 raw_count++;
 864         tx_buf_raw[raw_count++] = SIXP_SEOF;
 865         return raw_count;
 866 }
 867
 868 /* decode 4 sixpack-encoded bytes into 3 data bytes */
 869
 870 static void decode_data(struct sixpack *sp, unsigned char inbyte)
 871 {
 872         unsigned char *buf;
 873
 874         if (sp->rx_count != 3) {
 875                 sp->raw_buf[sp->rx_count++] = inbyte;
 876
 877                 return;
 878         }
 879
 880         buf = sp->raw_buf;
 881         sp->cooked_buf[sp->rx_count_cooked++] =
 882                 buf[0] | ((buf[1] << 2) & 0xc0);
 883         sp->cooked_buf[sp->rx_count_cooked++] =
 884                 (buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
 885         sp->cooked_buf[sp->rx_count_cooked++] =
 886                 (buf[2] & 0x03) | (inbyte << 2);
 887         sp->rx_count = 0;
 888 }
 889
 890 /* identify and execute a 6pack priority command byte */
 891
 892 static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
 893 {
 894         unsigned char channel;
 895         int actual;
 896
 897         channel = cmd & SIXP_CHN_MASK;
 898         if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {     /* idle ? */
 899
 900         /* RX and DCD flags can only be set in the same prio command,
 901            if the DCD flag has been set without the RX flag in the previous
 902            prio command. If DCD has not been set before, something in the
 903            transmission has gone wrong. In this case, RX and DCD are
 904            cleared in order to prevent the decode_data routine from
 905            reading further data that might be corrupt. */
 906
 907                 if (((sp->status & SIXP_DCD_MASK) == 0) &&
 908                         ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
 909                                 if (sp->status != 1)
 910                                         printk(KERN_DEBUG "6pack: protocol violation\n");
 911                                 else
 912                                         sp->status = 0;
 913                                 cmd &= ~SIXP_RX_DCD_MASK;
 914                 }
 915                 sp->status = cmd & SIXP_PRIO_DATA_MASK;
 916         } else { /* output watchdog char if idle */
 917                 if ((sp->status2 != 0) && (sp->duplex == 1)) {
 918                         sp->led_state = 0x70;
 919                         sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 920                         sp->tx_enable = 1;
 921                         actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
 922                         sp->xleft -= actual;
 923                         sp->xhead += actual;
 924                         sp->led_state = 0x60;
 925                         sp->status2 = 0;
 926
 927                 }
 928         }
 929
 930         /* needed to trigger the TNC watchdog */
 931         sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 932
 933         /* if the state byte has been received, the TNC is present,
 934            so the resync timer can be reset. */
 935
 936         if (sp->tnc_state == TNC_IN_SYNC) {
 937                 del_timer(&sp->resync_t);
 938                 sp->resync_t.data       = (unsigned long) sp;
 939                 sp->resync_t.function   = resync_tnc;
 940                 sp->resync_t.expires    = jiffies + SIXP_INIT_RESYNC_TIMEOUT;
 941                 add_timer(&sp->resync_t);
 942         }
 943
 944         sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
 945 }
 946
 947 /* identify and execute a standard 6pack command byte */
 948
 949 static void decode_std_command(struct sixpack *sp, unsigned char cmd)
 950 {
 951         unsigned char checksum = 0, rest = 0, channel;
 952         short i;
 953
 954         channel = cmd & SIXP_CHN_MASK;
 955         switch (cmd & SIXP_CMD_MASK) {     /* normal command */
 956         case SIXP_SEOF:
 957                 if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
 958                         if ((sp->status & SIXP_RX_DCD_MASK) ==
 959                                 SIXP_RX_DCD_MASK) {
 960                                 sp->led_state = 0x68;
 961                                 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 962                         }
 963                 } else {
 964                         sp->led_state = 0x60;
 965                         /* fill trailing bytes with zeroes */
 966                         sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 967                         rest = sp->rx_count;
 968                         if (rest != 0)
 969                                  for (i = rest; i <= 3; i++)
 970                                         decode_data(sp, 0);
 971                         if (rest == 2)
 972                                 sp->rx_count_cooked -= 2;
 973                         else if (rest == 3)
 974                                 sp->rx_count_cooked -= 1;
 975                         for (i = 0; i < sp->rx_count_cooked; i++)
 976                                 checksum += sp->cooked_buf[i];
 977                         if (checksum != SIXP_CHKSUM) {
 978                                 printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
 979                         } else {
 980                                 sp->rcount = sp->rx_count_cooked-2;
 981                                 sp_bump(sp, 0);
 982                         }
 983                         sp->rx_count_cooked = 0;
 984                 }
 985                 break;
 986         case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
 987                 break;
 988         case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
 989                 break;
 990         case SIXP_RX_BUF_OVL:
 991                 printk(KERN_DEBUG "6pack: RX buffer overflow\n");
 992         }
 993 }
 994
 995 /* decode a 6pack packet */
 996
 997 static void
 998 sixpack_decode(struct sixpack *sp, unsigned char *pre_rbuff, int count)
 999 {
1000         unsigned char inbyte;
1001         int count1;
1002
1003         for (count1 = 0; count1 < count; count1++) {
1004                 inbyte = pre_rbuff[count1];
1005                 if (inbyte == SIXP_FOUND_TNC) {
1006                         tnc_set_sync_state(sp, TNC_IN_SYNC);
1007                         del_timer(&sp->resync_t);
1008                 }
1009                 if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
1010                         decode_prio_command(sp, inbyte);
1011                 else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
1012                         decode_std_command(sp, inbyte);
1013                 else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
1014                         decode_data(sp, inbyte);
1015         }
1016 }
1017
1018 MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
1019 MODULE_DESCRIPTION("6pack driver for AX.25");
1020 MODULE_LICENSE("GPL");
1021 MODULE_ALIAS_LDISC(N_6PACK);
1022
1023 module_init(sixpack_init_driver);
1024 module_exit(sixpack_exit_driver);