1 /*****************************************************************************/
2
3 /*
4 * hdlcdrv.c -- HDLC packet radio network driver.
5 *
6 * Copyright (C) 1996-2000 Thomas Sailer (sailer@ife.ee.ethz.ch)
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 * Please note that the GPL allows you to use the driver, NOT the radio.
23 * In order to use the radio, you need a license from the communications
24 * authority of your country.
25 *
26 * The driver was derived from Donald Beckers skeleton.c
27 * Written 1993-94 by Donald Becker.
28 *
29 * History:
30 * 0.1 21.09.1996 Started
31 * 18.10.1996 Changed to new user space access routines
32 * (copy_{to,from}_user)
33 * 0.2 21.11.1996 various small changes
34 * 0.3 03.03.1997 fixed (hopefully) IP not working with ax.25 as a module
35 * 0.4 16.04.1997 init code/data tagged
36 * 0.5 30.07.1997 made HDLC buffers bigger (solves a problem with the
37 * soundmodem driver)
38 * 0.6 05.04.1998 add spinlocks
39 * 0.7 03.08.1999 removed some old compatibility cruft
40 * 0.8 12.02.2000 adapted to softnet driver interface
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 /* prototypes for ax25_encapsulate and ax25_rebuild_header */
64 #include <net/ax25.h>
65
66 /* make genksyms happy */
67 #include <linux/ip.h>
68 #include <linux/udp.h>
69 #include <linux/tcp.h>
70
71 /* --------------------------------------------------------------------- */
72
73 /*
74 * The name of the card. Is used for messages and in the requests for
75 * io regions, irqs and dma channels
76 */
77
78 static char ax25_bcast[AX25_ADDR_LEN] =
79 {'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1};
80 static 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 * the CRC routines are stolen from WAMPES
100 * by Dieter Deyke
101 */
102
103 static 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
append_crc_ccitt(unsigned char * buffer,int len)140 static 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
check_crc_ccitt(const unsigned char * buf,int cnt)153 static 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
165 static 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 * The HDLC routines
183 */
184
hdlc_rx_add_bytes(struct hdlcdrv_state * s,unsigned int bits,int num)185 static 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
hdlc_rx_flag(struct net_device * dev,struct hdlcdrv_state * s)203 static 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; /* KISS kludge */
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; /* KISS kludge */
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
hdlcdrv_receiver(struct net_device * dev,struct hdlcdrv_state * s)229 void 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 /* HDLCDRV_DEBUG */
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; /* abort received */
257 else if ((s->hdlcrx.bitstream & mask2) == mask3) {
258 /* flag received */
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 /* stuffed bit */
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
do_kiss_params(struct hdlcdrv_state * s,unsigned char * data,unsigned long len)285 static 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 /* KISS_VERBOSE */
292 #define PKP(a,b)
293 #endif /* KISS_VERBOSE */
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
hdlcdrv_transmitter(struct net_device * dev,struct hdlcdrv_state * s)326 void 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; /* strip KISS byte */
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; /* the appended CRC */
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
start_tx(struct net_device * dev,struct hdlcdrv_state * s)424 static 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
436 static unsigned short random_seed;
437
random_num(void)438 static inline unsigned short random_num(void)
439 {
440 random_seed = 28629 * random_seed + 157;
441 return random_seed;
442 }
443
444 /* ---------------------------------------------------------------------- */
445
hdlcdrv_arbitrate(struct net_device * dev,struct hdlcdrv_state * s)446 void 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 * ===================== network driver interface =========================
469 */
470
hdlcdrv_paranoia_check(struct net_device * dev,const char * routine)471 static 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
hdlcdrv_send_packet(struct sk_buff * skb,struct net_device * dev)485 static 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
hdlcdrv_set_mac_address(struct net_device * dev,void * addr)506 static int hdlcdrv_set_mac_address(struct net_device *dev, void *addr)
507 {
508 struct sockaddr *sa = (struct sockaddr *)addr;
509
510 /* addr is an AX.25 shifted ASCII mac address */
511 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
512 return 0;
513 }
514
515 /* --------------------------------------------------------------------- */
516
hdlcdrv_get_stats(struct net_device * dev)517 static 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 * Get the current statistics. This may be called with the
526 * card open or closed.
527 */
528 return &sm->stats;
529 }
530
531 /* --------------------------------------------------------------------- */
532 /*
533 * Open/initialize the board. This is called (in the current kernel)
534 * sometime after booting when the 'ifconfig' program is run.
535 *
536 * This routine should set everything up anew at each open, even
537 * registers that "should" only need to be set once at boot, so that
538 * there is non-reboot way to recover if something goes wrong.
539 */
540
hdlcdrv_open(struct net_device * dev)541 static 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 * initialise some variables
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 * The inverse routine to hdlcdrv_open().
579 */
580
hdlcdrv_close(struct net_device * dev)581 static 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
hdlcdrv_ioctl(struct net_device * dev,struct ifreq * ifr,int cmd)600 static 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 /* HDLCDRV_DEBUG */
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 /* HDLCDRV_DEBUG */
698
699 case HDLCDRVCTL_GETBITS:
700 #ifndef HDLCDRV_DEBUG
701 return -EPERM;
702 #else /* HDLCDRV_DEBUG */
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 /* HDLCDRV_DEBUG */
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 * Check for a network adaptor of this type, and return '0' if one exists.
732 * If dev->base_addr == 0, probe all likely locations.
733 * If dev->base_addr == 1, always return failure.
734 * If dev->base_addr == 2, allocate space for the device and return success
735 * (detachable devices only).
736 */
hdlcdrv_probe(struct net_device * dev)737 static 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 * not a real probe! only initialize data structures
748 */
749 s = (struct hdlcdrv_state *)dev->priv;
750 /*
751 * initialize the hdlcdrv_state struct
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 /* HDLCDRV_DEBUG */
778
779 /*
780 * initialize the device struct
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 /* Fill in the fields of the device structure */
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 /* CONFIG_AX25 || CONFIG_AX25_MODULE */
796 dev->hard_header = NULL;
797 dev->rebuild_header = NULL;
798 #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
799 dev->set_mac_address = hdlcdrv_set_mac_address;
800
801 dev->type = ARPHRD_AX25; /* AF_AX25 device */
802 dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
803 dev->mtu = AX25_DEF_PACLEN; /* eth_mtu is the default */
804 dev->addr_len = AX25_ADDR_LEN; /* sizeof an ax.25 address */
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 /* New style flags */
810 dev->flags = 0;
811
812 return 0;
813 }
814
815 /* --------------------------------------------------------------------- */
816
hdlcdrv_register_hdlcdrv(struct net_device * dev,const struct hdlcdrv_ops * ops,unsigned int privsize,char * ifname,unsigned int baseaddr,unsigned int irq,unsigned int dma)817 int 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 * initialize part of the hdlcdrv_state struct
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 * initialize part of the device struct
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
hdlcdrv_unregister_hdlcdrv(struct net_device * dev)858 int 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
878 EXPORT_SYMBOL(hdlcdrv_receiver);
879 EXPORT_SYMBOL(hdlcdrv_transmitter);
880 EXPORT_SYMBOL(hdlcdrv_arbitrate);
881 EXPORT_SYMBOL(hdlcdrv_register_hdlcdrv);
882 EXPORT_SYMBOL(hdlcdrv_unregister_hdlcdrv);
883
884 /* --------------------------------------------------------------------- */
885
hdlcdrv_init_driver(void)886 static 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
hdlcdrv_cleanup_driver(void)895 static void __exit hdlcdrv_cleanup_driver(void)
896 {
897 printk(KERN_INFO "hdlcdrv: cleanup\n");
898 }
899
900 /* --------------------------------------------------------------------- */
901
902 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
903 MODULE_DESCRIPTION("Packet Radio network interface HDLC encoder/decoder");
904 MODULE_LICENSE("GPL");
905 module_init(hdlcdrv_init_driver);
906 module_exit(hdlcdrv_cleanup_driver);
907
908 /* --------------------------------------------------------------------- */
909