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