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