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