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