[go: up one dir, main page]
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * 6pack.c This module implements the 6pack protocol for kernel-based
4 * devices like TTY. It interfaces between a raw TTY and the
5 * kernel's AX.25 protocol layers.
6 *
7 * Authors: Andreas Könsgen <ajk@comnets.uni-bremen.de>
8 * Ralf Baechle DL5RB <ralf@linux-mips.org>
9 *
10 * Quite a lot of stuff "stolen" by Joerg Reuter from slip.c, written by
11 *
12 * Laurence Culhane, <loz@holmes.demon.co.uk>
13 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
14 */
15
16#include <linux/module.h>
17#include <linux/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 <linux/slab.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 <linux/semaphore.h>
38#include <linux/refcount.h>
39
40/* sixpack priority commands */
41#define SIXP_SEOF 0x40 /* start and end of a 6pack frame */
42#define SIXP_TX_URUN 0x48 /* transmit overrun */
43#define SIXP_RX_ORUN 0x50 /* receive overrun */
44#define SIXP_RX_BUF_OVL 0x58 /* receive buffer overflow */
45
46#define SIXP_CHKSUM 0xFF /* valid checksum of a 6pack frame */
47
48/* masks to get certain bits out of the status bytes sent by the TNC */
49
50#define SIXP_CMD_MASK 0xC0
51#define SIXP_CHN_MASK 0x07
52#define SIXP_PRIO_CMD_MASK 0x80
53#define SIXP_STD_CMD_MASK 0x40
54#define SIXP_PRIO_DATA_MASK 0x38
55#define SIXP_TX_MASK 0x20
56#define SIXP_RX_MASK 0x10
57#define SIXP_RX_DCD_MASK 0x18
58#define SIXP_LEDS_ON 0x78
59#define SIXP_LEDS_OFF 0x60
60#define SIXP_CON 0x08
61#define SIXP_STA 0x10
62
63#define SIXP_FOUND_TNC 0xe9
64#define SIXP_CON_ON 0x68
65#define SIXP_DCD_MASK 0x08
66#define SIXP_DAMA_OFF 0
67
68/* default level 2 parameters */
69#define SIXP_TXDELAY 25 /* 250 ms */
70#define SIXP_PERSIST 50 /* in 256ths */
71#define SIXP_SLOTTIME 10 /* 100 ms */
72#define SIXP_INIT_RESYNC_TIMEOUT (3*HZ/2) /* in 1 s */
73#define SIXP_RESYNC_TIMEOUT 5*HZ /* in 1 s */
74
75/* 6pack configuration. */
76#define SIXP_NRUNIT 31 /* MAX number of 6pack channels */
77#define SIXP_MTU 256 /* Default MTU */
78
79enum sixpack_flags {
80 SIXPF_ERROR, /* Parity, etc. error */
81};
82
83struct sixpack {
84 /* Various fields. */
85 struct tty_struct *tty; /* ptr to TTY structure */
86 struct net_device *dev; /* easy for intr handling */
87
88 /* These are pointers to the malloc()ed frame buffers. */
89 int rcount; /* received chars counter */
90 unsigned char *xbuff; /* transmitter buffer */
91 unsigned char *xhead; /* next byte to XMIT */
92 int xleft; /* bytes left in XMIT queue */
93
94 u8 raw_buf[4];
95 u8 cooked_buf[400];
96
97 unsigned int rx_count;
98 unsigned int rx_count_cooked;
99 spinlock_t rxlock;
100
101 unsigned long flags; /* Flag values/ mode etc */
102 unsigned char mode; /* 6pack mode */
103
104 /* 6pack stuff */
105 unsigned char tx_delay;
106 unsigned char persistence;
107 unsigned char slottime;
108 unsigned char duplex;
109 unsigned char led_state;
110 u8 status;
111 u8 status1;
112 unsigned char status2;
113 unsigned char tx_enable;
114 unsigned char tnc_state;
115
116 struct timer_list tx_t;
117 struct timer_list resync_t;
118 spinlock_t lock;
119};
120
121#define AX25_6PACK_HEADER_LEN 0
122
123static void sixpack_decode(struct sixpack *, const u8 *, size_t);
124static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
125
126/*
127 * Perform the persistence/slottime algorithm for CSMA access. If the
128 * persistence check was successful, write the data to the serial driver.
129 * Note that in case of DAMA operation, the data is not sent here.
130 */
131
132static void sp_xmit_on_air(struct timer_list *t)
133{
134 struct sixpack *sp = timer_container_of(sp, t, tx_t);
135 int actual, when = sp->slottime;
136 static unsigned char random;
137
138 random = random * 17 + 41;
139
140 if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
141 sp->led_state = 0x70;
142 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
143 sp->tx_enable = 1;
144 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
145 sp->xleft -= actual;
146 sp->xhead += actual;
147 sp->led_state = 0x60;
148 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
149 sp->status2 = 0;
150 } else
151 mod_timer(timer: &sp->tx_t, expires: jiffies + ((when + 1) * HZ) / 100);
152}
153
154/* ----> 6pack timer interrupt handler and friends. <---- */
155
156/* Encapsulate one AX.25 frame and stuff into a TTY queue. */
157static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
158{
159 unsigned char *msg, *p = icp;
160 int actual, count;
161
162 if (len > AX25_MTU + 73) {
163 msg = "oversized transmit packet!";
164 goto out_drop;
165 }
166
167 if (p[0] > 5) {
168 msg = "invalid KISS command";
169 goto out_drop;
170 }
171
172 if ((p[0] != 0) && (len > 2)) {
173 msg = "KISS control packet too long";
174 goto out_drop;
175 }
176
177 if ((p[0] == 0) && (len < 15)) {
178 msg = "bad AX.25 packet to transmit";
179 goto out_drop;
180 }
181
182 count = encode_sixpack(p, sp->xbuff, len, sp->tx_delay);
183 set_bit(nr: TTY_DO_WRITE_WAKEUP, addr: &sp->tty->flags);
184
185 switch (p[0]) {
186 case 1: sp->tx_delay = p[1];
187 return;
188 case 2: sp->persistence = p[1];
189 return;
190 case 3: sp->slottime = p[1];
191 return;
192 case 4: /* ignored */
193 return;
194 case 5: sp->duplex = p[1];
195 return;
196 }
197
198 if (p[0] != 0)
199 return;
200
201 /*
202 * In case of fullduplex or DAMA operation, we don't take care about the
203 * state of the DCD or of any timers, as the determination of the
204 * correct time to send is the job of the AX.25 layer. We send
205 * immediately after data has arrived.
206 */
207 if (sp->duplex == 1) {
208 sp->led_state = 0x70;
209 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
210 sp->tx_enable = 1;
211 actual = sp->tty->ops->write(sp->tty, sp->xbuff, count);
212 sp->xleft = count - actual;
213 sp->xhead = sp->xbuff + actual;
214 sp->led_state = 0x60;
215 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
216 } else {
217 sp->xleft = count;
218 sp->xhead = sp->xbuff;
219 sp->status2 = count;
220 sp_xmit_on_air(t: &sp->tx_t);
221 }
222
223 return;
224
225out_drop:
226 sp->dev->stats.tx_dropped++;
227 netif_start_queue(dev: sp->dev);
228 if (net_ratelimit())
229 printk(KERN_DEBUG "%s: %s - dropped.\n", sp->dev->name, msg);
230}
231
232/* Encapsulate an IP datagram and kick it into a TTY queue. */
233
234static netdev_tx_t sp_xmit(struct sk_buff *skb, struct net_device *dev)
235{
236 struct sixpack *sp = netdev_priv(dev);
237
238 if (skb->protocol == htons(ETH_P_IP))
239 return ax25_ip_xmit(skb);
240
241 spin_lock_bh(lock: &sp->lock);
242 /* We were not busy, so we are now... :-) */
243 netif_stop_queue(dev);
244 dev->stats.tx_bytes += skb->len;
245 sp_encaps(sp, icp: skb->data, len: skb->len);
246 spin_unlock_bh(lock: &sp->lock);
247
248 dev_kfree_skb(skb);
249
250 return NETDEV_TX_OK;
251}
252
253static int sp_open_dev(struct net_device *dev)
254{
255 struct sixpack *sp = netdev_priv(dev);
256
257 if (sp->tty == NULL)
258 return -ENODEV;
259 return 0;
260}
261
262/* Close the low-level part of the 6pack channel. */
263static int sp_close(struct net_device *dev)
264{
265 struct sixpack *sp = netdev_priv(dev);
266
267 spin_lock_bh(lock: &sp->lock);
268 if (sp->tty) {
269 /* TTY discipline is running. */
270 clear_bit(nr: TTY_DO_WRITE_WAKEUP, addr: &sp->tty->flags);
271 }
272 netif_stop_queue(dev);
273 spin_unlock_bh(lock: &sp->lock);
274
275 return 0;
276}
277
278static int sp_set_mac_address(struct net_device *dev, void *addr)
279{
280 struct sockaddr_ax25 *sa = addr;
281
282 netif_tx_lock_bh(dev);
283 netif_addr_lock(dev);
284 __dev_addr_set(dev, addr: &sa->sax25_call, AX25_ADDR_LEN);
285 netif_addr_unlock(dev);
286 netif_tx_unlock_bh(dev);
287
288 return 0;
289}
290
291static const struct net_device_ops sp_netdev_ops = {
292 .ndo_open = sp_open_dev,
293 .ndo_stop = sp_close,
294 .ndo_start_xmit = sp_xmit,
295 .ndo_set_mac_address = sp_set_mac_address,
296};
297
298static void sp_setup(struct net_device *dev)
299{
300 /* Finish setting up the DEVICE info. */
301 dev->netdev_ops = &sp_netdev_ops;
302 dev->mtu = SIXP_MTU;
303 dev->hard_header_len = AX25_MAX_HEADER_LEN;
304 dev->header_ops = &ax25_header_ops;
305
306 dev->addr_len = AX25_ADDR_LEN;
307 dev->type = ARPHRD_AX25;
308 dev->tx_queue_len = 10;
309
310 /* Only activated in AX.25 mode */
311 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
312 dev_addr_set(dev, addr: (u8 *)&ax25_defaddr);
313
314 dev->flags = 0;
315}
316
317/* Send one completely decapsulated IP datagram to the IP layer. */
318
319/*
320 * This is the routine that sends the received data to the kernel AX.25.
321 * 'cmd' is the KISS command. For AX.25 data, it is zero.
322 */
323
324static void sp_bump(struct sixpack *sp, char cmd)
325{
326 struct sk_buff *skb;
327 int count;
328 u8 *ptr;
329
330 count = sp->rcount + 1;
331
332 sp->dev->stats.rx_bytes += count;
333
334 if ((skb = dev_alloc_skb(length: count + 1)) == NULL)
335 goto out_mem;
336
337 ptr = skb_put(skb, len: count + 1);
338 *ptr++ = cmd; /* KISS command */
339
340 memcpy(ptr, sp->cooked_buf + 1, count);
341 skb->protocol = ax25_type_trans(skb, dev: sp->dev);
342 netif_rx(skb);
343 sp->dev->stats.rx_packets++;
344
345 return;
346
347out_mem:
348 sp->dev->stats.rx_dropped++;
349}
350
351
352/* ----------------------------------------------------------------------- */
353
354/*
355 * Called by the TTY driver when there's room for more data. If we have
356 * more packets to send, we send them here.
357 */
358static void sixpack_write_wakeup(struct tty_struct *tty)
359{
360 struct sixpack *sp = tty->disc_data;
361 int actual;
362
363 if (!sp)
364 return;
365 if (sp->xleft <= 0) {
366 /* Now serial buffer is almost free & we can start
367 * transmission of another packet */
368 sp->dev->stats.tx_packets++;
369 clear_bit(nr: TTY_DO_WRITE_WAKEUP, addr: &tty->flags);
370 sp->tx_enable = 0;
371 netif_wake_queue(dev: sp->dev);
372 return;
373 }
374
375 if (sp->tx_enable) {
376 actual = tty->ops->write(tty, sp->xhead, sp->xleft);
377 sp->xleft -= actual;
378 sp->xhead += actual;
379 }
380}
381
382/* ----------------------------------------------------------------------- */
383
384/*
385 * Handle the 'receiver data ready' interrupt.
386 * This function is called by the tty module in the kernel when
387 * a block of 6pack data has been received, which can now be decapsulated
388 * and sent on to some IP layer for further processing.
389 */
390static void sixpack_receive_buf(struct tty_struct *tty, const u8 *cp,
391 const u8 *fp, size_t count)
392{
393 struct sixpack *sp;
394 size_t count1;
395
396 if (!count)
397 return;
398
399 sp = tty->disc_data;
400 if (!sp)
401 return;
402
403 /* Read the characters out of the buffer */
404 count1 = count;
405 while (count) {
406 count--;
407 if (fp && *fp++) {
408 if (!test_and_set_bit(nr: SIXPF_ERROR, addr: &sp->flags))
409 sp->dev->stats.rx_errors++;
410 continue;
411 }
412 }
413 sixpack_decode(sp, cp, count1);
414
415 tty_unthrottle(tty);
416}
417
418/*
419 * Try to resync the TNC. Called by the resync timer defined in
420 * decode_prio_command
421 */
422
423#define TNC_UNINITIALIZED 0
424#define TNC_UNSYNC_STARTUP 1
425#define TNC_UNSYNCED 2
426#define TNC_IN_SYNC 3
427
428static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
429{
430 char *msg;
431
432 switch (new_tnc_state) {
433 default: /* gcc oh piece-o-crap ... */
434 case TNC_UNSYNC_STARTUP:
435 msg = "Synchronizing with TNC";
436 break;
437 case TNC_UNSYNCED:
438 msg = "Lost synchronization with TNC\n";
439 break;
440 case TNC_IN_SYNC:
441 msg = "Found TNC";
442 break;
443 }
444
445 sp->tnc_state = new_tnc_state;
446 printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
447}
448
449static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
450{
451 int old_tnc_state = sp->tnc_state;
452
453 if (old_tnc_state != new_tnc_state)
454 __tnc_set_sync_state(sp, new_tnc_state);
455}
456
457static void resync_tnc(struct timer_list *t)
458{
459 struct sixpack *sp = timer_container_of(sp, t, resync_t);
460 static char resync_cmd = 0xe8;
461
462 /* clear any data that might have been received */
463
464 sp->rx_count = 0;
465 sp->rx_count_cooked = 0;
466
467 /* reset state machine */
468
469 sp->status = 1;
470 sp->status1 = 1;
471 sp->status2 = 0;
472
473 /* resync the TNC */
474
475 sp->led_state = 0x60;
476 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
477 sp->tty->ops->write(sp->tty, &resync_cmd, 1);
478
479
480 /* Start resync timer again -- the TNC might be still absent */
481 mod_timer(timer: &sp->resync_t, expires: jiffies + SIXP_RESYNC_TIMEOUT);
482}
483
484static inline int tnc_init(struct sixpack *sp)
485{
486 unsigned char inbyte = 0xe8;
487
488 tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
489
490 sp->tty->ops->write(sp->tty, &inbyte, 1);
491
492 mod_timer(timer: &sp->resync_t, expires: jiffies + SIXP_RESYNC_TIMEOUT);
493
494 return 0;
495}
496
497/*
498 * Open the high-level part of the 6pack channel.
499 * This function is called by the TTY module when the
500 * 6pack line discipline is called for. Because we are
501 * sure the tty line exists, we only have to link it to
502 * a free 6pcack channel...
503 */
504static int sixpack_open(struct tty_struct *tty)
505{
506 char *xbuff = NULL;
507 struct net_device *dev;
508 struct sixpack *sp;
509 unsigned long len;
510 int err = 0;
511
512 if (!capable(CAP_NET_ADMIN))
513 return -EPERM;
514 if (tty->ops->write == NULL)
515 return -EOPNOTSUPP;
516
517 dev = alloc_netdev(sizeof(struct sixpack), "sp%d", NET_NAME_UNKNOWN,
518 sp_setup);
519 if (!dev) {
520 err = -ENOMEM;
521 goto out;
522 }
523
524 sp = netdev_priv(dev);
525 sp->dev = dev;
526
527 spin_lock_init(&sp->lock);
528 spin_lock_init(&sp->rxlock);
529
530 /* !!! length of the buffers. MTU is IP MTU, not PACLEN! */
531
532 len = dev->mtu * 2;
533
534 xbuff = kmalloc(len + 4, GFP_KERNEL);
535 if (xbuff == NULL) {
536 err = -ENOBUFS;
537 goto out_free;
538 }
539
540 spin_lock_bh(lock: &sp->lock);
541
542 sp->tty = tty;
543
544 sp->xbuff = xbuff;
545
546 sp->rcount = 0;
547 sp->rx_count = 0;
548 sp->rx_count_cooked = 0;
549 sp->xleft = 0;
550
551 sp->flags = 0; /* Clear ESCAPE & ERROR flags */
552
553 sp->duplex = 0;
554 sp->tx_delay = SIXP_TXDELAY;
555 sp->persistence = SIXP_PERSIST;
556 sp->slottime = SIXP_SLOTTIME;
557 sp->led_state = 0x60;
558 sp->status = 1;
559 sp->status1 = 1;
560 sp->status2 = 0;
561 sp->tx_enable = 0;
562
563 netif_start_queue(dev);
564
565 timer_setup(&sp->tx_t, sp_xmit_on_air, 0);
566
567 timer_setup(&sp->resync_t, resync_tnc, 0);
568
569 spin_unlock_bh(lock: &sp->lock);
570
571 /* Done. We have linked the TTY line to a channel. */
572 tty->disc_data = sp;
573 tty->receive_room = 65536;
574
575 /* Now we're ready to register. */
576 err = register_netdev(dev);
577 if (err)
578 goto out_free;
579
580 tnc_init(sp);
581
582 return 0;
583
584out_free:
585 kfree(objp: xbuff);
586
587 free_netdev(dev);
588
589out:
590 return err;
591}
592
593
594/*
595 * Close down a 6pack channel.
596 * This means flushing out any pending queues, and then restoring the
597 * TTY line discipline to what it was before it got hooked to 6pack
598 * (which usually is TTY again).
599 */
600static void sixpack_close(struct tty_struct *tty)
601{
602 struct sixpack *sp;
603
604 sp = tty->disc_data;
605 if (!sp)
606 return;
607
608 tty->disc_data = NULL;
609
610 /* We must stop the queue to avoid potentially scribbling
611 * on the free buffers. The sp->dead completion is not sufficient
612 * to protect us from sp->xbuff access.
613 */
614 netif_stop_queue(dev: sp->dev);
615
616 unregister_netdev(dev: sp->dev);
617
618 timer_delete_sync(timer: &sp->tx_t);
619 timer_delete_sync(timer: &sp->resync_t);
620
621 /* Free all 6pack frame buffers after unreg. */
622 kfree(objp: sp->xbuff);
623
624 free_netdev(dev: sp->dev);
625}
626
627/* Perform I/O control on an active 6pack channel. */
628static int sixpack_ioctl(struct tty_struct *tty, unsigned int cmd,
629 unsigned long arg)
630{
631 struct sixpack *sp = tty->disc_data;
632 struct net_device *dev;
633 unsigned int tmp, err;
634
635 if (!sp)
636 return -ENXIO;
637 dev = sp->dev;
638
639 switch(cmd) {
640 case SIOCGIFNAME:
641 err = copy_to_user(to: (void __user *) arg, from: dev->name,
642 strlen(dev->name) + 1) ? -EFAULT : 0;
643 break;
644
645 case SIOCGIFENCAP:
646 err = put_user(0, (int __user *) arg);
647 break;
648
649 case SIOCSIFENCAP:
650 if (get_user(tmp, (int __user *) arg)) {
651 err = -EFAULT;
652 break;
653 }
654
655 sp->mode = tmp;
656 dev->addr_len = AX25_ADDR_LEN;
657 dev->hard_header_len = AX25_KISS_HEADER_LEN +
658 AX25_MAX_HEADER_LEN + 3;
659 dev->type = ARPHRD_AX25;
660
661 err = 0;
662 break;
663
664 case SIOCSIFHWADDR: {
665 char addr[AX25_ADDR_LEN];
666
667 if (copy_from_user(to: &addr,
668 from: (void __user *)arg, AX25_ADDR_LEN)) {
669 err = -EFAULT;
670 break;
671 }
672
673 netif_tx_lock_bh(dev);
674 __dev_addr_set(dev, addr: &addr, AX25_ADDR_LEN);
675 netif_tx_unlock_bh(dev);
676 err = 0;
677 break;
678 }
679 default:
680 err = tty_mode_ioctl(tty, cmd, arg);
681 }
682
683 return err;
684}
685
686static struct tty_ldisc_ops sp_ldisc = {
687 .owner = THIS_MODULE,
688 .num = N_6PACK,
689 .name = "6pack",
690 .open = sixpack_open,
691 .close = sixpack_close,
692 .ioctl = sixpack_ioctl,
693 .receive_buf = sixpack_receive_buf,
694 .write_wakeup = sixpack_write_wakeup,
695};
696
697/* Initialize 6pack control device -- register 6pack line discipline */
698
699static int __init sixpack_init_driver(void)
700{
701 int status;
702
703 /* Register the provided line protocol discipline */
704 status = tty_register_ldisc(new_ldisc: &sp_ldisc);
705 if (status)
706 pr_err("6pack: can't register line discipline (err = %d)\n", status);
707
708 return status;
709}
710
711static void __exit sixpack_exit_driver(void)
712{
713 tty_unregister_ldisc(ldisc: &sp_ldisc);
714}
715
716/* encode an AX.25 packet into 6pack */
717
718static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
719 int length, unsigned char tx_delay)
720{
721 int count = 0;
722 unsigned char checksum = 0, buf[400];
723 int raw_count = 0;
724
725 tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
726 tx_buf_raw[raw_count++] = SIXP_SEOF;
727
728 buf[0] = tx_delay;
729 for (count = 1; count < length; count++)
730 buf[count] = tx_buf[count];
731
732 for (count = 0; count < length; count++)
733 checksum += buf[count];
734 buf[length] = (unsigned char) 0xff - checksum;
735
736 for (count = 0; count <= length; count++) {
737 if ((count % 3) == 0) {
738 tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
739 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
740 } else if ((count % 3) == 1) {
741 tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
742 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x3c);
743 } else {
744 tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
745 tx_buf_raw[raw_count++] = (buf[count] >> 2);
746 }
747 }
748 if ((length % 3) != 2)
749 raw_count++;
750 tx_buf_raw[raw_count++] = SIXP_SEOF;
751 return raw_count;
752}
753
754/* decode 4 sixpack-encoded bytes into 3 data bytes */
755
756static void decode_data(struct sixpack *sp, u8 inbyte)
757{
758 u8 *buf;
759
760 if (sp->rx_count != 3) {
761 sp->raw_buf[sp->rx_count++] = inbyte;
762
763 return;
764 }
765
766 if (sp->rx_count_cooked + 2 >= sizeof(sp->cooked_buf)) {
767 pr_err("6pack: cooked buffer overrun, data loss\n");
768 sp->rx_count = 0;
769 return;
770 }
771
772 buf = sp->raw_buf;
773 sp->cooked_buf[sp->rx_count_cooked++] =
774 buf[0] | ((buf[1] << 2) & 0xc0);
775 sp->cooked_buf[sp->rx_count_cooked++] =
776 (buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
777 sp->cooked_buf[sp->rx_count_cooked++] =
778 (buf[2] & 0x03) | (inbyte << 2);
779 sp->rx_count = 0;
780}
781
782/* identify and execute a 6pack priority command byte */
783
784static void decode_prio_command(struct sixpack *sp, u8 cmd)
785{
786 ssize_t actual;
787
788 if ((cmd & SIXP_PRIO_DATA_MASK) != 0) { /* idle ? */
789
790 /* RX and DCD flags can only be set in the same prio command,
791 if the DCD flag has been set without the RX flag in the previous
792 prio command. If DCD has not been set before, something in the
793 transmission has gone wrong. In this case, RX and DCD are
794 cleared in order to prevent the decode_data routine from
795 reading further data that might be corrupt. */
796
797 if (((sp->status & SIXP_DCD_MASK) == 0) &&
798 ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
799 if (sp->status != 1)
800 printk(KERN_DEBUG "6pack: protocol violation\n");
801 else
802 sp->status = 0;
803 cmd &= ~SIXP_RX_DCD_MASK;
804 }
805 sp->status = cmd & SIXP_PRIO_DATA_MASK;
806 } else { /* output watchdog char if idle */
807 if ((sp->status2 != 0) && (sp->duplex == 1)) {
808 sp->led_state = 0x70;
809 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
810 sp->tx_enable = 1;
811 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
812 sp->xleft -= actual;
813 sp->xhead += actual;
814 sp->led_state = 0x60;
815 sp->status2 = 0;
816
817 }
818 }
819
820 /* needed to trigger the TNC watchdog */
821 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
822
823 /* if the state byte has been received, the TNC is present,
824 so the resync timer can be reset. */
825
826 if (sp->tnc_state == TNC_IN_SYNC)
827 mod_timer(timer: &sp->resync_t, expires: jiffies + SIXP_INIT_RESYNC_TIMEOUT);
828
829 sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
830}
831
832/* identify and execute a standard 6pack command byte */
833
834static void decode_std_command(struct sixpack *sp, u8 cmd)
835{
836 u8 checksum = 0, rest = 0;
837 short i;
838
839 switch (cmd & SIXP_CMD_MASK) { /* normal command */
840 case SIXP_SEOF:
841 if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
842 if ((sp->status & SIXP_RX_DCD_MASK) ==
843 SIXP_RX_DCD_MASK) {
844 sp->led_state = 0x68;
845 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
846 }
847 } else {
848 sp->led_state = 0x60;
849 /* fill trailing bytes with zeroes */
850 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
851 spin_lock_bh(lock: &sp->rxlock);
852 rest = sp->rx_count;
853 if (rest != 0)
854 for (i = rest; i <= 3; i++)
855 decode_data(sp, inbyte: 0);
856 if (rest == 2)
857 sp->rx_count_cooked -= 2;
858 else if (rest == 3)
859 sp->rx_count_cooked -= 1;
860 for (i = 0; i < sp->rx_count_cooked; i++)
861 checksum += sp->cooked_buf[i];
862 if (checksum != SIXP_CHKSUM) {
863 printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
864 } else {
865 sp->rcount = sp->rx_count_cooked-2;
866 sp_bump(sp, cmd: 0);
867 }
868 sp->rx_count_cooked = 0;
869 spin_unlock_bh(lock: &sp->rxlock);
870 }
871 break;
872 case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
873 break;
874 case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
875 break;
876 case SIXP_RX_BUF_OVL:
877 printk(KERN_DEBUG "6pack: RX buffer overflow\n");
878 }
879}
880
881/* decode a 6pack packet */
882
883static void
884sixpack_decode(struct sixpack *sp, const u8 *pre_rbuff, size_t count)
885{
886 size_t count1;
887 u8 inbyte;
888
889 for (count1 = 0; count1 < count; count1++) {
890 inbyte = pre_rbuff[count1];
891 if (inbyte == SIXP_FOUND_TNC) {
892 tnc_set_sync_state(sp, TNC_IN_SYNC);
893 timer_delete(timer: &sp->resync_t);
894 }
895 if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
896 decode_prio_command(sp, cmd: inbyte);
897 else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
898 decode_std_command(sp, cmd: inbyte);
899 else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK) {
900 spin_lock_bh(lock: &sp->rxlock);
901 decode_data(sp, inbyte);
902 spin_unlock_bh(lock: &sp->rxlock);
903 }
904 }
905}
906
907MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
908MODULE_DESCRIPTION("6pack driver for AX.25");
909MODULE_LICENSE("GPL");
910MODULE_ALIAS_LDISC(N_6PACK);
911
912module_init(sixpack_init_driver);
913module_exit(sixpack_exit_driver);
914

source code of linux/drivers/net/hamradio/6pack.c