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