1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include <linux/config.h>
46#include <linux/version.h>
47#include <linux/module.h>
48#include <linux/types.h>
49#include <linux/net.h>
50#include <linux/in.h>
51#include <linux/if.h>
52#include <linux/slab.h>
53#include <linux/errno.h>
54#include <linux/init.h>
55#include <asm/bitops.h>
56#include <asm/uaccess.h>
57
58#include <linux/netdevice.h>
59#include <linux/if_arp.h>
60#include <linux/etherdevice.h>
61#include <linux/skbuff.h>
62#include <linux/hdlcdrv.h>
63
64#include <net/ax25.h>
65
66
67#include <linux/ip.h>
68#include <linux/udp.h>
69#include <linux/tcp.h>
70
71
72
73
74
75
76
77
78static char ax25_bcast[AX25_ADDR_LEN] =
79{'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1};
80static char ax25_nocall[AX25_ADDR_LEN] =
81{'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1};
82
83
84
85#define KISS_VERBOSE
86
87
88
89#define PARAM_TXDELAY 1
90#define PARAM_PERSIST 2
91#define PARAM_SLOTTIME 3
92#define PARAM_TXTAIL 4
93#define PARAM_FULLDUP 5
94#define PARAM_HARDWARE 6
95#define PARAM_RETURN 255
96
97
98
99
100
101
102
103static const unsigned short crc_ccitt_table[] = {
104 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
105 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
106 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
107 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
108 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
109 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
110 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
111 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
112 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
113 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
114 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
115 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
116 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
117 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
118 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
119 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
120 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
121 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
122 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
123 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
124 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
125 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
126 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
127 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
128 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
129 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
130 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
131 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
132 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
133 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
134 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
135 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
136};
137
138
139
140static inline void append_crc_ccitt(unsigned char *buffer, int len)
141{
142 unsigned int crc = 0xffff;
143
144 for (;len>0;len--)
145 crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buffer++) & 0xff];
146 crc ^= 0xffff;
147 *buffer++ = crc;
148 *buffer++ = crc >> 8;
149}
150
151
152
153static inline int check_crc_ccitt(const unsigned char *buf, int cnt)
154{
155 unsigned int crc = 0xffff;
156
157 for (; cnt > 0; cnt--)
158 crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
159 return (crc & 0xffff) == 0xf0b8;
160}
161
162
163
164#if 0
165static int calc_crc_ccitt(const unsigned char *buf, int cnt)
166{
167 unsigned int crc = 0xffff;
168
169 for (; cnt > 0; cnt--)
170 crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
171 crc ^= 0xffff;
172 return (crc & 0xffff);
173}
174#endif
175
176
177
178#define tenms_to_2flags(s,tenms) ((tenms * s->par.bitrate) / 100 / 16)
179
180
181
182
183
184
185static int hdlc_rx_add_bytes(struct hdlcdrv_state *s, unsigned int bits,
186 int num)
187{
188 int added = 0;
189
190 while (s->hdlcrx.rx_state && num >= 8) {
191 if (s->hdlcrx.len >= sizeof(s->hdlcrx.buffer)) {
192 s->hdlcrx.rx_state = 0;
193 return 0;
194 }
195 *s->hdlcrx.bp++ = bits >> (32-num);
196 s->hdlcrx.len++;
197 num -= 8;
198 added += 8;
199 }
200 return added;
201}
202
203static void hdlc_rx_flag(struct net_device *dev, struct hdlcdrv_state *s)
204{
205 struct sk_buff *skb;
206 int pkt_len;
207 unsigned char *cp;
208
209 if (s->hdlcrx.len < 4)
210 return;
211 if (!check_crc_ccitt(s->hdlcrx.buffer, s->hdlcrx.len))
212 return;
213 pkt_len = s->hdlcrx.len - 2 + 1;
214 if (!(skb = dev_alloc_skb(pkt_len))) {
215 printk("%s: memory squeeze, dropping packet\n", dev->name);
216 s->stats.rx_dropped++;
217 return;
218 }
219 skb->dev = dev;
220 cp = skb_put(skb, pkt_len);
221 *cp++ = 0;
222 memcpy(cp, s->hdlcrx.buffer, pkt_len - 1);
223 skb->protocol = htons(ETH_P_AX25);
224 skb->mac.raw = skb->data;
225 netif_rx(skb);
226 s->stats.rx_packets++;
227}
228
229void hdlcdrv_receiver(struct net_device *dev, struct hdlcdrv_state *s)
230{
231 int i;
232 unsigned int mask1, mask2, mask3, mask4, mask5, mask6, word;
233
234 if (!s || s->magic != HDLCDRV_MAGIC)
235 return;
236 if (test_and_set_bit(0, &s->hdlcrx.in_hdlc_rx))
237 return;
238
239 while (!hdlcdrv_hbuf_empty(&s->hdlcrx.hbuf)) {
240 word = hdlcdrv_hbuf_get(&s->hdlcrx.hbuf);
241
242#ifdef HDLCDRV_DEBUG
243 hdlcdrv_add_bitbuffer_word(&s->bitbuf_hdlc, word);
244#endif
245 s->hdlcrx.bitstream >>= 16;
246 s->hdlcrx.bitstream |= word << 16;
247 s->hdlcrx.bitbuf >>= 16;
248 s->hdlcrx.bitbuf |= word << 16;
249 s->hdlcrx.numbits += 16;
250 for(i = 15, mask1 = 0x1fc00, mask2 = 0x1fe00, mask3 = 0x0fc00,
251 mask4 = 0x1f800, mask5 = 0xf800, mask6 = 0xffff;
252 i >= 0;
253 i--, mask1 <<= 1, mask2 <<= 1, mask3 <<= 1, mask4 <<= 1,
254 mask5 <<= 1, mask6 = (mask6 << 1) | 1) {
255 if ((s->hdlcrx.bitstream & mask1) == mask1)
256 s->hdlcrx.rx_state = 0;
257 else if ((s->hdlcrx.bitstream & mask2) == mask3) {
258
259 if (s->hdlcrx.rx_state) {
260 hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf
261 << (8+i),
262 s->hdlcrx.numbits
263 -8-i);
264 hdlc_rx_flag(dev, s);
265 }
266 s->hdlcrx.len = 0;
267 s->hdlcrx.bp = s->hdlcrx.buffer;
268 s->hdlcrx.rx_state = 1;
269 s->hdlcrx.numbits = i;
270 } else if ((s->hdlcrx.bitstream & mask4) == mask5) {
271
272 s->hdlcrx.numbits--;
273 s->hdlcrx.bitbuf = (s->hdlcrx.bitbuf & (~mask6)) |
274 ((s->hdlcrx.bitbuf & mask6) << 1);
275 }
276 }
277 s->hdlcrx.numbits -= hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf,
278 s->hdlcrx.numbits);
279 }
280 clear_bit(0, &s->hdlcrx.in_hdlc_rx);
281}
282
283
284
285static inline void do_kiss_params(struct hdlcdrv_state *s,
286 unsigned char *data, unsigned long len)
287{
288
289#ifdef KISS_VERBOSE
290#define PKP(a,b) printk(KERN_INFO "hdlcdrv.c: channel params: " a "\n", b)
291#else
292#define PKP(a,b)
293#endif
294
295 if (len < 2)
296 return;
297 switch(data[0]) {
298 case PARAM_TXDELAY:
299 s->ch_params.tx_delay = data[1];
300 PKP("TX delay = %ums", 10 * s->ch_params.tx_delay);
301 break;
302 case PARAM_PERSIST:
303 s->ch_params.ppersist = data[1];
304 PKP("p persistence = %u", s->ch_params.ppersist);
305 break;
306 case PARAM_SLOTTIME:
307 s->ch_params.slottime = data[1];
308 PKP("slot time = %ums", s->ch_params.slottime);
309 break;
310 case PARAM_TXTAIL:
311 s->ch_params.tx_tail = data[1];
312 PKP("TX tail = %ums", s->ch_params.tx_tail);
313 break;
314 case PARAM_FULLDUP:
315 s->ch_params.fulldup = !!data[1];
316 PKP("%s duplex", s->ch_params.fulldup ? "full" : "half");
317 break;
318 default:
319 break;
320 }
321#undef PKP
322}
323
324
325
326void hdlcdrv_transmitter(struct net_device *dev, struct hdlcdrv_state *s)
327{
328 unsigned int mask1, mask2, mask3;
329 int i;
330 struct sk_buff *skb;
331 int pkt_len;
332
333 if (!s || s->magic != HDLCDRV_MAGIC)
334 return;
335 if (test_and_set_bit(0, &s->hdlctx.in_hdlc_tx))
336 return;
337 for (;;) {
338 if (s->hdlctx.numbits >= 16) {
339 if (hdlcdrv_hbuf_full(&s->hdlctx.hbuf)) {
340 clear_bit(0, &s->hdlctx.in_hdlc_tx);
341 return;
342 }
343 hdlcdrv_hbuf_put(&s->hdlctx.hbuf, s->hdlctx.bitbuf);
344 s->hdlctx.bitbuf >>= 16;
345 s->hdlctx.numbits -= 16;
346 }
347 switch (s->hdlctx.tx_state) {
348 default:
349 clear_bit(0, &s->hdlctx.in_hdlc_tx);
350 return;
351 case 0:
352 case 1:
353 if (s->hdlctx.numflags) {
354 s->hdlctx.numflags--;
355 s->hdlctx.bitbuf |=
356 0x7e7e << s->hdlctx.numbits;
357 s->hdlctx.numbits += 16;
358 break;
359 }
360 if (s->hdlctx.tx_state == 1) {
361 clear_bit(0, &s->hdlctx.in_hdlc_tx);
362 return;
363 }
364 if (!(skb = s->skb)) {
365 int flgs = tenms_to_2flags(s, s->ch_params.tx_tail);
366 if (flgs < 2)
367 flgs = 2;
368 s->hdlctx.tx_state = 1;
369 s->hdlctx.numflags = flgs;
370 break;
371 }
372 s->skb = NULL;
373 netif_wake_queue(dev);
374 pkt_len = skb->len-1;
375 if (pkt_len >= HDLCDRV_MAXFLEN || pkt_len < 2) {
376 s->hdlctx.tx_state = 0;
377 s->hdlctx.numflags = 1;
378 dev_kfree_skb_irq(skb);
379 break;
380 }
381 memcpy(s->hdlctx.buffer, skb->data+1, pkt_len);
382 dev_kfree_skb_irq(skb);
383 s->hdlctx.bp = s->hdlctx.buffer;
384 append_crc_ccitt(s->hdlctx.buffer, pkt_len);
385 s->hdlctx.len = pkt_len+2;
386 s->hdlctx.tx_state = 2;
387 s->hdlctx.bitstream = 0;
388 s->stats.tx_packets++;
389 break;
390 case 2:
391 if (!s->hdlctx.len) {
392 s->hdlctx.tx_state = 0;
393 s->hdlctx.numflags = 1;
394 break;
395 }
396 s->hdlctx.len--;
397 s->hdlctx.bitbuf |= *s->hdlctx.bp <<
398 s->hdlctx.numbits;
399 s->hdlctx.bitstream >>= 8;
400 s->hdlctx.bitstream |= (*s->hdlctx.bp++) << 16;
401 mask1 = 0x1f000;
402 mask2 = 0x10000;
403 mask3 = 0xffffffff >> (31-s->hdlctx.numbits);
404 s->hdlctx.numbits += 8;
405 for(i = 0; i < 8; i++, mask1 <<= 1, mask2 <<= 1,
406 mask3 = (mask3 << 1) | 1) {
407 if ((s->hdlctx.bitstream & mask1) != mask1)
408 continue;
409 s->hdlctx.bitstream &= ~mask2;
410 s->hdlctx.bitbuf =
411 (s->hdlctx.bitbuf & mask3) |
412 ((s->hdlctx.bitbuf &
413 (~mask3)) << 1);
414 s->hdlctx.numbits++;
415 mask3 = (mask3 << 1) | 1;
416 }
417 break;
418 }
419 }
420}
421
422
423
424static void start_tx(struct net_device *dev, struct hdlcdrv_state *s)
425{
426 s->hdlctx.tx_state = 0;
427 s->hdlctx.numflags = tenms_to_2flags(s, s->ch_params.tx_delay);
428 s->hdlctx.bitbuf = s->hdlctx.bitstream = s->hdlctx.numbits = 0;
429 hdlcdrv_transmitter(dev, s);
430 s->hdlctx.ptt = 1;
431 s->ptt_keyed++;
432}
433
434
435
436static unsigned short random_seed;
437
438static inline unsigned short random_num(void)
439{
440 random_seed = 28629 * random_seed + 157;
441 return random_seed;
442}
443
444
445
446void hdlcdrv_arbitrate(struct net_device *dev, struct hdlcdrv_state *s)
447{
448 if (!s || s->magic != HDLCDRV_MAGIC || s->hdlctx.ptt || !s->skb)
449 return;
450 if (s->ch_params.fulldup) {
451 start_tx(dev, s);
452 return;
453 }
454 if (s->hdlcrx.dcd) {
455 s->hdlctx.slotcnt = s->ch_params.slottime;
456 return;
457 }
458 if ((--s->hdlctx.slotcnt) > 0)
459 return;
460 s->hdlctx.slotcnt = s->ch_params.slottime;
461 if ((random_num() % 256) > s->ch_params.ppersist)
462 return;
463 start_tx(dev, s);
464}
465
466
467
468
469
470
471static inline int hdlcdrv_paranoia_check(struct net_device *dev,
472 const char *routine)
473{
474 if (!dev || !dev->priv ||
475 ((struct hdlcdrv_state *)dev->priv)->magic != HDLCDRV_MAGIC) {
476 printk(KERN_ERR "hdlcdrv: bad magic number for hdlcdrv_state "
477 "struct in routine %s\n", routine);
478 return 1;
479 }
480 return 0;
481}
482
483
484
485static int hdlcdrv_send_packet(struct sk_buff *skb, struct net_device *dev)
486{
487 struct hdlcdrv_state *sm;
488
489 if (hdlcdrv_paranoia_check(dev, "hdlcdrv_send_packet"))
490 return 0;
491 sm = (struct hdlcdrv_state *)dev->priv;
492 if (skb->data[0] != 0) {
493 do_kiss_params(sm, skb->data, skb->len);
494 dev_kfree_skb(skb);
495 return 0;
496 }
497 if (sm->skb)
498 return -1;
499 netif_stop_queue(dev);
500 sm->skb = skb;
501 return 0;
502}
503
504
505
506static int hdlcdrv_set_mac_address(struct net_device *dev, void *addr)
507{
508 struct sockaddr *sa = (struct sockaddr *)addr;
509
510
511 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
512 return 0;
513}
514
515
516
517static struct net_device_stats *hdlcdrv_get_stats(struct net_device *dev)
518{
519 struct hdlcdrv_state *sm;
520
521 if (hdlcdrv_paranoia_check(dev, "hdlcdrv_get_stats"))
522 return NULL;
523 sm = (struct hdlcdrv_state *)dev->priv;
524
525
526
527
528 return &sm->stats;
529}
530
531
532
533
534
535
536
537
538
539
540
541static int hdlcdrv_open(struct net_device *dev)
542{
543 struct hdlcdrv_state *s;
544 int i;
545
546 if (hdlcdrv_paranoia_check(dev, "hdlcdrv_open"))
547 return -EINVAL;
548 s = (struct hdlcdrv_state *)dev->priv;
549
550 if (!s->ops || !s->ops->open)
551 return -ENODEV;
552
553
554
555
556 s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
557 s->hdlcrx.in_hdlc_rx = 0;
558 s->hdlcrx.rx_state = 0;
559
560 s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
561 s->hdlctx.in_hdlc_tx = 0;
562 s->hdlctx.tx_state = 1;
563 s->hdlctx.numflags = 0;
564 s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
565 s->hdlctx.ptt = 0;
566 s->hdlctx.slotcnt = s->ch_params.slottime;
567 s->hdlctx.calibrate = 0;
568
569 i = s->ops->open(dev);
570 if (i)
571 return i;
572 netif_start_queue(dev);
573 return 0;
574}
575
576
577
578
579
580
581static int hdlcdrv_close(struct net_device *dev)
582{
583 struct hdlcdrv_state *s;
584 int i = 0;
585
586 if (hdlcdrv_paranoia_check(dev, "hdlcdrv_close"))
587 return -EINVAL;
588 s = (struct hdlcdrv_state *)dev->priv;
589
590 if (s->ops && s->ops->close)
591 i = s->ops->close(dev);
592 if (s->skb)
593 dev_kfree_skb(s->skb);
594 s->skb = NULL;
595 return i;
596}
597
598
599
600static int hdlcdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
601{
602 struct hdlcdrv_state *s;
603 struct hdlcdrv_ioctl bi;
604
605 if (hdlcdrv_paranoia_check(dev, "hdlcdrv_ioctl"))
606 return -EINVAL;
607 s = (struct hdlcdrv_state *)dev->priv;
608
609 if (cmd != SIOCDEVPRIVATE) {
610 if (s->ops && s->ops->ioctl)
611 return s->ops->ioctl(dev, ifr, &bi, cmd);
612 return -ENOIOCTLCMD;
613 }
614 if (copy_from_user(&bi, ifr->ifr_data, sizeof(bi)))
615 return -EFAULT;
616
617 switch (bi.cmd) {
618 default:
619 if (s->ops && s->ops->ioctl)
620 return s->ops->ioctl(dev, ifr, &bi, cmd);
621 return -ENOIOCTLCMD;
622
623 case HDLCDRVCTL_GETCHANNELPAR:
624 bi.data.cp.tx_delay = s->ch_params.tx_delay;
625 bi.data.cp.tx_tail = s->ch_params.tx_tail;
626 bi.data.cp.slottime = s->ch_params.slottime;
627 bi.data.cp.ppersist = s->ch_params.ppersist;
628 bi.data.cp.fulldup = s->ch_params.fulldup;
629 break;
630
631 case HDLCDRVCTL_SETCHANNELPAR:
632 if (!capable(CAP_NET_ADMIN))
633 return -EACCES;
634 s->ch_params.tx_delay = bi.data.cp.tx_delay;
635 s->ch_params.tx_tail = bi.data.cp.tx_tail;
636 s->ch_params.slottime = bi.data.cp.slottime;
637 s->ch_params.ppersist = bi.data.cp.ppersist;
638 s->ch_params.fulldup = bi.data.cp.fulldup;
639 s->hdlctx.slotcnt = 1;
640 return 0;
641
642 case HDLCDRVCTL_GETMODEMPAR:
643 bi.data.mp.iobase = dev->base_addr;
644 bi.data.mp.irq = dev->irq;
645 bi.data.mp.dma = dev->dma;
646 bi.data.mp.dma2 = s->ptt_out.dma2;
647 bi.data.mp.seriobase = s->ptt_out.seriobase;
648 bi.data.mp.pariobase = s->ptt_out.pariobase;
649 bi.data.mp.midiiobase = s->ptt_out.midiiobase;
650 break;
651
652 case HDLCDRVCTL_SETMODEMPAR:
653 if ((!capable(CAP_SYS_RAWIO)) || netif_running(dev))
654 return -EACCES;
655 dev->base_addr = bi.data.mp.iobase;
656 dev->irq = bi.data.mp.irq;
657 dev->dma = bi.data.mp.dma;
658 s->ptt_out.dma2 = bi.data.mp.dma2;
659 s->ptt_out.seriobase = bi.data.mp.seriobase;
660 s->ptt_out.pariobase = bi.data.mp.pariobase;
661 s->ptt_out.midiiobase = bi.data.mp.midiiobase;
662 return 0;
663
664 case HDLCDRVCTL_GETSTAT:
665 bi.data.cs.ptt = hdlcdrv_ptt(s);
666 bi.data.cs.dcd = s->hdlcrx.dcd;
667 bi.data.cs.ptt_keyed = s->ptt_keyed;
668 bi.data.cs.tx_packets = s->stats.tx_packets;
669 bi.data.cs.tx_errors = s->stats.tx_errors;
670 bi.data.cs.rx_packets = s->stats.rx_packets;
671 bi.data.cs.rx_errors = s->stats.rx_errors;
672 break;
673
674 case HDLCDRVCTL_OLDGETSTAT:
675 bi.data.ocs.ptt = hdlcdrv_ptt(s);
676 bi.data.ocs.dcd = s->hdlcrx.dcd;
677 bi.data.ocs.ptt_keyed = s->ptt_keyed;
678 break;
679
680 case HDLCDRVCTL_CALIBRATE:
681 if(!capable(CAP_SYS_RAWIO))
682 return -EPERM;
683 s->hdlctx.calibrate = bi.data.calibrate * s->par.bitrate / 16;
684 return 0;
685
686 case HDLCDRVCTL_GETSAMPLES:
687#ifndef HDLCDRV_DEBUG
688 return -EPERM;
689#else
690 if (s->bitbuf_channel.rd == s->bitbuf_channel.wr)
691 return -EAGAIN;
692 bi.data.bits =
693 s->bitbuf_channel.buffer[s->bitbuf_channel.rd];
694 s->bitbuf_channel.rd = (s->bitbuf_channel.rd+1) %
695 sizeof(s->bitbuf_channel.buffer);
696 break;
697#endif
698
699 case HDLCDRVCTL_GETBITS:
700#ifndef HDLCDRV_DEBUG
701 return -EPERM;
702#else
703 if (s->bitbuf_hdlc.rd == s->bitbuf_hdlc.wr)
704 return -EAGAIN;
705 bi.data.bits =
706 s->bitbuf_hdlc.buffer[s->bitbuf_hdlc.rd];
707 s->bitbuf_hdlc.rd = (s->bitbuf_hdlc.rd+1) %
708 sizeof(s->bitbuf_hdlc.buffer);
709 break;
710#endif
711
712 case HDLCDRVCTL_DRIVERNAME:
713 if (s->ops && s->ops->drvname) {
714 strncpy(bi.data.drivername, s->ops->drvname,
715 sizeof(bi.data.drivername));
716 break;
717 }
718 bi.data.drivername[0] = '\0';
719 break;
720
721 }
722 if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
723 return -EFAULT;
724 return 0;
725
726}
727
728
729
730
731
732
733
734
735
736
737static int hdlcdrv_probe(struct net_device *dev)
738{
739 const struct hdlcdrv_channel_params dflt_ch_params = {
740 20, 2, 10, 40, 0
741 };
742 struct hdlcdrv_state *s;
743
744 if (!dev)
745 return -ENXIO;
746
747
748
749 s = (struct hdlcdrv_state *)dev->priv;
750
751
752
753 s->ch_params = dflt_ch_params;
754 s->ptt_keyed = 0;
755
756 spin_lock_init(&s->hdlcrx.hbuf.lock);
757 s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
758 s->hdlcrx.in_hdlc_rx = 0;
759 s->hdlcrx.rx_state = 0;
760
761 spin_lock_init(&s->hdlctx.hbuf.lock);
762 s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
763 s->hdlctx.in_hdlc_tx = 0;
764 s->hdlctx.tx_state = 1;
765 s->hdlctx.numflags = 0;
766 s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
767 s->hdlctx.ptt = 0;
768 s->hdlctx.slotcnt = s->ch_params.slottime;
769 s->hdlctx.calibrate = 0;
770
771#ifdef HDLCDRV_DEBUG
772 s->bitbuf_channel.rd = s->bitbuf_channel.wr = 0;
773 s->bitbuf_channel.shreg = 0x80;
774
775 s->bitbuf_hdlc.rd = s->bitbuf_hdlc.wr = 0;
776 s->bitbuf_hdlc.shreg = 0x80;
777#endif
778
779
780
781
782 dev->open = hdlcdrv_open;
783 dev->stop = hdlcdrv_close;
784 dev->do_ioctl = hdlcdrv_ioctl;
785 dev->hard_start_xmit = hdlcdrv_send_packet;
786 dev->get_stats = hdlcdrv_get_stats;
787
788
789
790 s->skb = NULL;
791
792#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
793 dev->hard_header = ax25_encapsulate;
794 dev->rebuild_header = ax25_rebuild_header;
795#else
796 dev->hard_header = NULL;
797 dev->rebuild_header = NULL;
798#endif
799 dev->set_mac_address = hdlcdrv_set_mac_address;
800
801 dev->type = ARPHRD_AX25;
802 dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
803 dev->mtu = AX25_DEF_PACLEN;
804 dev->addr_len = AX25_ADDR_LEN;
805 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
806 memcpy(dev->dev_addr, ax25_nocall, AX25_ADDR_LEN);
807 dev->tx_queue_len = 16;
808
809
810 dev->flags = 0;
811
812 return 0;
813}
814
815
816
817int hdlcdrv_register_hdlcdrv(struct net_device *dev, const struct hdlcdrv_ops *ops,
818 unsigned int privsize, char *ifname,
819 unsigned int baseaddr, unsigned int irq,
820 unsigned int dma)
821{
822 struct hdlcdrv_state *s;
823
824 if (!dev || !ops)
825 return -EACCES;
826 if (privsize < sizeof(struct hdlcdrv_state))
827 privsize = sizeof(struct hdlcdrv_state);
828 memset(dev, 0, sizeof(struct net_device));
829 if (!(s = dev->priv = kmalloc(privsize, GFP_KERNEL)))
830 return -ENOMEM;
831
832
833
834 memset(s, 0, privsize);
835 s->magic = HDLCDRV_MAGIC;
836 strncpy(dev->name, ifname, sizeof(dev->name));
837 s->ops = ops;
838
839
840
841 dev->if_port = 0;
842 dev->init = hdlcdrv_probe;
843 dev->base_addr = baseaddr;
844 dev->irq = irq;
845 dev->dma = dma;
846 if (register_netdev(dev)) {
847 printk(KERN_WARNING "hdlcdrv: cannot register net "
848 "device %s\n", dev->name);
849 kfree(dev->priv);
850 return -ENXIO;
851 }
852 MOD_INC_USE_COUNT;
853 return 0;
854}
855
856
857
858int hdlcdrv_unregister_hdlcdrv(struct net_device *dev)
859{
860 struct hdlcdrv_state *s;
861
862 if (!dev)
863 return -EINVAL;
864 if (!(s = (struct hdlcdrv_state *)dev->priv))
865 return -EINVAL;
866 if (s->magic != HDLCDRV_MAGIC)
867 return -EINVAL;
868 if (s->ops->close)
869 s->ops->close(dev);
870 unregister_netdev(dev);
871 kfree(s);
872 MOD_DEC_USE_COUNT;
873 return 0;
874}
875
876
877
878EXPORT_SYMBOL(hdlcdrv_receiver);
879EXPORT_SYMBOL(hdlcdrv_transmitter);
880EXPORT_SYMBOL(hdlcdrv_arbitrate);
881EXPORT_SYMBOL(hdlcdrv_register_hdlcdrv);
882EXPORT_SYMBOL(hdlcdrv_unregister_hdlcdrv);
883
884
885
886static int __init hdlcdrv_init_driver(void)
887{
888 printk(KERN_INFO "hdlcdrv: (C) 1996-2000 Thomas Sailer HB9JNX/AE4WA\n");
889 printk(KERN_INFO "hdlcdrv: version 0.8 compiled " __TIME__ " " __DATE__ "\n");
890 return 0;
891}
892
893
894
895static void __exit hdlcdrv_cleanup_driver(void)
896{
897 printk(KERN_INFO "hdlcdrv: cleanup\n");
898}
899
900
901
902MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
903MODULE_DESCRIPTION("Packet Radio network interface HDLC encoder/decoder");
904MODULE_LICENSE("GPL");
905module_init(hdlcdrv_init_driver);
906module_exit(hdlcdrv_cleanup_driver);
907
908
909
