?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
SLUB: Fix memory leak by not reusing cpu_slab
[pv_ops_mirror.git] / drivers / net / hamradio / 6pack.c
blobe0119f6a3319b2fca40af251d7bd3bf09dcde038
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, const void *daddr,
292 const void *saddr, unsigned len)
293 {
294 #ifdef CONFIG_INET
295 if (type != ETH_P_AX25)
296 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
297 #endif
298 return 0;
299 }
300
301 static struct net_device_stats *sp_get_stats(struct net_device *dev)
302 {
303 struct sixpack *sp = netdev_priv(dev);
304 return &sp->stats;
305 }
306
307 static int sp_set_mac_address(struct net_device *dev, void *addr)
308 {
309 struct sockaddr_ax25 *sa = addr;
310
311 netif_tx_lock_bh(dev);
312 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
313 netif_tx_unlock_bh(dev);
314
315 return 0;
316 }
317
318 static int sp_rebuild_header(struct sk_buff *skb)
319 {
320 #ifdef CONFIG_INET
321 return ax25_rebuild_header(skb);
322 #else
323 return 0;
324 #endif
325 }
326
327 static const struct header_ops sp_header_ops = {
328 .create = sp_header,
329 .rebuild = sp_rebuild_header,
330 };
331
332 static void sp_setup(struct net_device *dev)
333 {
334 /* Finish setting up the DEVICE info. */
335 dev->mtu = SIXP_MTU;
336 dev->hard_start_xmit = sp_xmit;
337 dev->open = sp_open_dev;
338 dev->destructor = free_netdev;
339 dev->stop = sp_close;
340
341 dev->get_stats = sp_get_stats;
342 dev->set_mac_address = sp_set_mac_address;
343 dev->hard_header_len = AX25_MAX_HEADER_LEN;
344 dev->header_ops = &sp_header_ops;
345
346 dev->addr_len = AX25_ADDR_LEN;
347 dev->type = ARPHRD_AX25;
348 dev->tx_queue_len = 10;
349 dev->tx_timeout = NULL;
350
351 /* Only activated in AX.25 mode */
352 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
353 memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
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);
Mirror for ia64_pv_ops.git