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