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