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