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