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/capability.h>
46 #include <linux/module.h>
47 #include <linux/types.h>
48 #include <linux/net.h>
49 #include <linux/in.h>
50 #include <linux/if.h>
51 #include <linux/errno.h>
52 #include <linux/init.h>
53 #include <linux/bitops.h>
54 
55 #include <linux/netdevice.h>
56 #include <linux/if_arp.h>
57 #include <linux/skbuff.h>
58 #include <linux/hdlcdrv.h>
59 #include <linux/random.h>
60 #include <net/ax25.h>
61 #include <asm/uaccess.h>
62 
63 #include <linux/crc-ccitt.h>
64 
65 /* --------------------------------------------------------------------- */
66 
67 #define KISS_VERBOSE
68 
69 /* --------------------------------------------------------------------- */
70 
71 #define PARAM_TXDELAY   1
72 #define PARAM_PERSIST   2
73 #define PARAM_SLOTTIME  3
74 #define PARAM_TXTAIL    4
75 #define PARAM_FULLDUP   5
76 #define PARAM_HARDWARE  6
77 #define PARAM_RETURN    255
78 
79 /* --------------------------------------------------------------------- */
80 /*
81  * the CRC routines are stolen from WAMPES
82  * by Dieter Deyke
83  */
84 
85 
86 /*---------------------------------------------------------------------------*/
87 
append_crc_ccitt(unsigned char * buffer,int len)88 static inline void append_crc_ccitt(unsigned char *buffer, int len)
89 {
90  	unsigned int crc = crc_ccitt(0xffff, buffer, len) ^ 0xffff;
91 	buffer += len;
92 	*buffer++ = crc;
93 	*buffer++ = crc >> 8;
94 }
95 
96 /*---------------------------------------------------------------------------*/
97 
check_crc_ccitt(const unsigned char * buf,int cnt)98 static inline int check_crc_ccitt(const unsigned char *buf, int cnt)
99 {
100 	return (crc_ccitt(0xffff, buf, cnt) & 0xffff) == 0xf0b8;
101 }
102 
103 /*---------------------------------------------------------------------------*/
104 
105 #if 0
106 static int calc_crc_ccitt(const unsigned char *buf, int cnt)
107 {
108 	unsigned int crc = 0xffff;
109 
110 	for (; cnt > 0; cnt--)
111 		crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
112 	crc ^= 0xffff;
113 	return crc & 0xffff;
114 }
115 #endif
116 
117 /* ---------------------------------------------------------------------- */
118 
119 #define tenms_to_2flags(s,tenms) ((tenms * s->par.bitrate) / 100 / 16)
120 
121 /* ---------------------------------------------------------------------- */
122 /*
123  * The HDLC routines
124  */
125 
hdlc_rx_add_bytes(struct hdlcdrv_state * s,unsigned int bits,int num)126 static int hdlc_rx_add_bytes(struct hdlcdrv_state *s, unsigned int bits,
127 			     int num)
128 {
129 	int added = 0;
130 
131 	while (s->hdlcrx.rx_state && num >= 8) {
132 		if (s->hdlcrx.len >= sizeof(s->hdlcrx.buffer)) {
133 			s->hdlcrx.rx_state = 0;
134 			return 0;
135 		}
136 		*s->hdlcrx.bp++ = bits >> (32-num);
137 		s->hdlcrx.len++;
138 		num -= 8;
139 		added += 8;
140 	}
141 	return added;
142 }
143 
hdlc_rx_flag(struct net_device * dev,struct hdlcdrv_state * s)144 static void hdlc_rx_flag(struct net_device *dev, struct hdlcdrv_state *s)
145 {
146 	struct sk_buff *skb;
147 	int pkt_len;
148 	unsigned char *cp;
149 
150 	if (s->hdlcrx.len < 4)
151 		return;
152 	if (!check_crc_ccitt(s->hdlcrx.buffer, s->hdlcrx.len))
153 		return;
154 	pkt_len = s->hdlcrx.len - 2 + 1; /* KISS kludge */
155 	if (!(skb = dev_alloc_skb(pkt_len))) {
156 		printk("%s: memory squeeze, dropping packet\n", dev->name);
157 		dev->stats.rx_dropped++;
158 		return;
159 	}
160 	cp = skb_put(skb, pkt_len);
161 	*cp++ = 0; /* KISS kludge */
162 	memcpy(cp, s->hdlcrx.buffer, pkt_len - 1);
163 	skb->protocol = ax25_type_trans(skb, dev);
164 	netif_rx(skb);
165 	dev->stats.rx_packets++;
166 }
167 
hdlcdrv_receiver(struct net_device * dev,struct hdlcdrv_state * s)168 void hdlcdrv_receiver(struct net_device *dev, struct hdlcdrv_state *s)
169 {
170 	int i;
171 	unsigned int mask1, mask2, mask3, mask4, mask5, mask6, word;
172 
173 	if (!s || s->magic != HDLCDRV_MAGIC)
174 		return;
175 	if (test_and_set_bit(0, &s->hdlcrx.in_hdlc_rx))
176 		return;
177 
178 	while (!hdlcdrv_hbuf_empty(&s->hdlcrx.hbuf)) {
179 		word = hdlcdrv_hbuf_get(&s->hdlcrx.hbuf);
180 
181 #ifdef HDLCDRV_DEBUG
182 		hdlcdrv_add_bitbuffer_word(&s->bitbuf_hdlc, word);
183 #endif /* HDLCDRV_DEBUG */
184 	       	s->hdlcrx.bitstream >>= 16;
185 		s->hdlcrx.bitstream |= word << 16;
186 		s->hdlcrx.bitbuf >>= 16;
187 		s->hdlcrx.bitbuf |= word << 16;
188 		s->hdlcrx.numbits += 16;
189 		for(i = 15, mask1 = 0x1fc00, mask2 = 0x1fe00, mask3 = 0x0fc00,
190 		    mask4 = 0x1f800, mask5 = 0xf800, mask6 = 0xffff;
191 		    i >= 0;
192 		    i--, mask1 <<= 1, mask2 <<= 1, mask3 <<= 1, mask4 <<= 1,
193 		    mask5 <<= 1, mask6 = (mask6 << 1) | 1) {
194 			if ((s->hdlcrx.bitstream & mask1) == mask1)
195 				s->hdlcrx.rx_state = 0; /* abort received */
196 			else if ((s->hdlcrx.bitstream & mask2) == mask3) {
197 				/* flag received */
198 				if (s->hdlcrx.rx_state) {
199 					hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf
200 							  << (8+i),
201 							  s->hdlcrx.numbits
202 							  -8-i);
203 					hdlc_rx_flag(dev, s);
204 				}
205 				s->hdlcrx.len = 0;
206 				s->hdlcrx.bp = s->hdlcrx.buffer;
207 				s->hdlcrx.rx_state = 1;
208 				s->hdlcrx.numbits = i;
209 			} else if ((s->hdlcrx.bitstream & mask4) == mask5) {
210 				/* stuffed bit */
211 				s->hdlcrx.numbits--;
212 				s->hdlcrx.bitbuf = (s->hdlcrx.bitbuf & (~mask6)) |
213 					((s->hdlcrx.bitbuf & mask6) << 1);
214 			}
215 		}
216 		s->hdlcrx.numbits -= hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf,
217 						       s->hdlcrx.numbits);
218 	}
219 	clear_bit(0, &s->hdlcrx.in_hdlc_rx);
220 }
221 
222 /* ---------------------------------------------------------------------- */
223 
do_kiss_params(struct hdlcdrv_state * s,unsigned char * data,unsigned long len)224 static inline void do_kiss_params(struct hdlcdrv_state *s,
225 				  unsigned char *data, unsigned long len)
226 {
227 
228 #ifdef KISS_VERBOSE
229 #define PKP(a,b) printk(KERN_INFO "hdlcdrv.c: channel params: " a "\n", b)
230 #else /* KISS_VERBOSE */
231 #define PKP(a,b)
232 #endif /* KISS_VERBOSE */
233 
234 	if (len < 2)
235 		return;
236 	switch(data[0]) {
237 	case PARAM_TXDELAY:
238 		s->ch_params.tx_delay = data[1];
239 		PKP("TX delay = %ums", 10 * s->ch_params.tx_delay);
240 		break;
241 	case PARAM_PERSIST:
242 		s->ch_params.ppersist = data[1];
243 		PKP("p persistence = %u", s->ch_params.ppersist);
244 		break;
245 	case PARAM_SLOTTIME:
246 		s->ch_params.slottime = data[1];
247 		PKP("slot time = %ums", s->ch_params.slottime);
248 		break;
249 	case PARAM_TXTAIL:
250 		s->ch_params.tx_tail = data[1];
251 		PKP("TX tail = %ums", s->ch_params.tx_tail);
252 		break;
253 	case PARAM_FULLDUP:
254 		s->ch_params.fulldup = !!data[1];
255 		PKP("%s duplex", s->ch_params.fulldup ? "full" : "half");
256 		break;
257 	default:
258 		break;
259 	}
260 #undef PKP
261 }
262 
263 /* ---------------------------------------------------------------------- */
264 
hdlcdrv_transmitter(struct net_device * dev,struct hdlcdrv_state * s)265 void hdlcdrv_transmitter(struct net_device *dev, struct hdlcdrv_state *s)
266 {
267 	unsigned int mask1, mask2, mask3;
268 	int i;
269 	struct sk_buff *skb;
270 	int pkt_len;
271 
272 	if (!s || s->magic != HDLCDRV_MAGIC)
273 		return;
274 	if (test_and_set_bit(0, &s->hdlctx.in_hdlc_tx))
275 		return;
276 	for (;;) {
277 		if (s->hdlctx.numbits >= 16) {
278 			if (hdlcdrv_hbuf_full(&s->hdlctx.hbuf)) {
279 				clear_bit(0, &s->hdlctx.in_hdlc_tx);
280 				return;
281 			}
282 			hdlcdrv_hbuf_put(&s->hdlctx.hbuf, s->hdlctx.bitbuf);
283 			s->hdlctx.bitbuf >>= 16;
284 			s->hdlctx.numbits -= 16;
285 		}
286 		switch (s->hdlctx.tx_state) {
287 		default:
288 			clear_bit(0, &s->hdlctx.in_hdlc_tx);
289 			return;
290 		case 0:
291 		case 1:
292 			if (s->hdlctx.numflags) {
293 				s->hdlctx.numflags--;
294 				s->hdlctx.bitbuf |=
295 					0x7e7e << s->hdlctx.numbits;
296 				s->hdlctx.numbits += 16;
297 				break;
298 			}
299 			if (s->hdlctx.tx_state == 1) {
300 				clear_bit(0, &s->hdlctx.in_hdlc_tx);
301 				return;
302 			}
303 			if (!(skb = s->skb)) {
304 				int flgs = tenms_to_2flags(s, s->ch_params.tx_tail);
305 				if (flgs < 2)
306 					flgs = 2;
307 				s->hdlctx.tx_state = 1;
308 				s->hdlctx.numflags = flgs;
309 				break;
310 			}
311 			s->skb = NULL;
312 			netif_wake_queue(dev);
313 			pkt_len = skb->len-1; /* strip KISS byte */
314 			if (pkt_len >= HDLCDRV_MAXFLEN || pkt_len < 2) {
315 				s->hdlctx.tx_state = 0;
316 				s->hdlctx.numflags = 1;
317 				dev_kfree_skb_irq(skb);
318 				break;
319 			}
320 			skb_copy_from_linear_data_offset(skb, 1,
321 							 s->hdlctx.buffer,
322 							 pkt_len);
323 			dev_kfree_skb_irq(skb);
324 			s->hdlctx.bp = s->hdlctx.buffer;
325 			append_crc_ccitt(s->hdlctx.buffer, pkt_len);
326 			s->hdlctx.len = pkt_len+2; /* the appended CRC */
327 			s->hdlctx.tx_state = 2;
328 			s->hdlctx.bitstream = 0;
329 			dev->stats.tx_packets++;
330 			break;
331 		case 2:
332 			if (!s->hdlctx.len) {
333 				s->hdlctx.tx_state = 0;
334 				s->hdlctx.numflags = 1;
335 				break;
336 			}
337 			s->hdlctx.len--;
338 			s->hdlctx.bitbuf |= *s->hdlctx.bp <<
339 				s->hdlctx.numbits;
340 			s->hdlctx.bitstream >>= 8;
341 			s->hdlctx.bitstream |= (*s->hdlctx.bp++) << 16;
342 			mask1 = 0x1f000;
343 			mask2 = 0x10000;
344 			mask3 = 0xffffffff >> (31-s->hdlctx.numbits);
345 			s->hdlctx.numbits += 8;
346 			for(i = 0; i < 8; i++, mask1 <<= 1, mask2 <<= 1,
347 			    mask3 = (mask3 << 1) | 1) {
348 				if ((s->hdlctx.bitstream & mask1) != mask1)
349 					continue;
350 				s->hdlctx.bitstream &= ~mask2;
351 				s->hdlctx.bitbuf =
352 					(s->hdlctx.bitbuf & mask3) |
353 						((s->hdlctx.bitbuf &
354 						 (~mask3)) << 1);
355 				s->hdlctx.numbits++;
356 				mask3 = (mask3 << 1) | 1;
357 			}
358 			break;
359 		}
360 	}
361 }
362 
363 /* ---------------------------------------------------------------------- */
364 
start_tx(struct net_device * dev,struct hdlcdrv_state * s)365 static void start_tx(struct net_device *dev, struct hdlcdrv_state *s)
366 {
367 	s->hdlctx.tx_state = 0;
368 	s->hdlctx.numflags = tenms_to_2flags(s, s->ch_params.tx_delay);
369 	s->hdlctx.bitbuf = s->hdlctx.bitstream = s->hdlctx.numbits = 0;
370 	hdlcdrv_transmitter(dev, s);
371 	s->hdlctx.ptt = 1;
372 	s->ptt_keyed++;
373 }
374 
375 /* ---------------------------------------------------------------------- */
376 
hdlcdrv_arbitrate(struct net_device * dev,struct hdlcdrv_state * s)377 void hdlcdrv_arbitrate(struct net_device *dev, struct hdlcdrv_state *s)
378 {
379 	if (!s || s->magic != HDLCDRV_MAGIC || s->hdlctx.ptt || !s->skb)
380 		return;
381 	if (s->ch_params.fulldup) {
382 		start_tx(dev, s);
383 		return;
384 	}
385 	if (s->hdlcrx.dcd) {
386 		s->hdlctx.slotcnt = s->ch_params.slottime;
387 		return;
388 	}
389 	if ((--s->hdlctx.slotcnt) > 0)
390 		return;
391 	s->hdlctx.slotcnt = s->ch_params.slottime;
392 	if ((random32() % 256) > s->ch_params.ppersist)
393 		return;
394 	start_tx(dev, s);
395 }
396 
397 /* --------------------------------------------------------------------- */
398 /*
399  * ===================== network driver interface =========================
400  */
401 
hdlcdrv_send_packet(struct sk_buff * skb,struct net_device * dev)402 static netdev_tx_t hdlcdrv_send_packet(struct sk_buff *skb,
403 				       struct net_device *dev)
404 {
405 	struct hdlcdrv_state *sm = netdev_priv(dev);
406 
407 	if (skb->data[0] != 0) {
408 		do_kiss_params(sm, skb->data, skb->len);
409 		dev_kfree_skb(skb);
410 		return NETDEV_TX_OK;
411 	}
412 	if (sm->skb)
413 		return NETDEV_TX_LOCKED;
414 	netif_stop_queue(dev);
415 	sm->skb = skb;
416 	return NETDEV_TX_OK;
417 }
418 
419 /* --------------------------------------------------------------------- */
420 
hdlcdrv_set_mac_address(struct net_device * dev,void * addr)421 static int hdlcdrv_set_mac_address(struct net_device *dev, void *addr)
422 {
423 	struct sockaddr *sa = (struct sockaddr *)addr;
424 
425 	/* addr is an AX.25 shifted ASCII mac address */
426 	memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
427 	return 0;
428 }
429 
430 /* --------------------------------------------------------------------- */
431 /*
432  * Open/initialize the board. This is called (in the current kernel)
433  * sometime after booting when the 'ifconfig' program is run.
434  *
435  * This routine should set everything up anew at each open, even
436  * registers that "should" only need to be set once at boot, so that
437  * there is non-reboot way to recover if something goes wrong.
438  */
439 
hdlcdrv_open(struct net_device * dev)440 static int hdlcdrv_open(struct net_device *dev)
441 {
442 	struct hdlcdrv_state *s = netdev_priv(dev);
443 	int i;
444 
445 	if (!s->ops || !s->ops->open)
446 		return -ENODEV;
447 
448 	/*
449 	 * initialise some variables
450 	 */
451 	s->opened = 1;
452 	s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
453 	s->hdlcrx.in_hdlc_rx = 0;
454 	s->hdlcrx.rx_state = 0;
455 
456 	s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
457 	s->hdlctx.in_hdlc_tx = 0;
458 	s->hdlctx.tx_state = 1;
459 	s->hdlctx.numflags = 0;
460 	s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
461 	s->hdlctx.ptt = 0;
462 	s->hdlctx.slotcnt = s->ch_params.slottime;
463 	s->hdlctx.calibrate = 0;
464 
465 	i = s->ops->open(dev);
466 	if (i)
467 		return i;
468 	netif_start_queue(dev);
469 	return 0;
470 }
471 
472 /* --------------------------------------------------------------------- */
473 /*
474  * The inverse routine to hdlcdrv_open().
475  */
476 
hdlcdrv_close(struct net_device * dev)477 static int hdlcdrv_close(struct net_device *dev)
478 {
479 	struct hdlcdrv_state *s = netdev_priv(dev);
480 	int i = 0;
481 
482 	netif_stop_queue(dev);
483 
484 	if (s->ops && s->ops->close)
485 		i = s->ops->close(dev);
486 	if (s->skb)
487 		dev_kfree_skb(s->skb);
488 	s->skb = NULL;
489 	s->opened = 0;
490 	return i;
491 }
492 
493 /* --------------------------------------------------------------------- */
494 
hdlcdrv_ioctl(struct net_device * dev,struct ifreq * ifr,int cmd)495 static int hdlcdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
496 {
497 	struct hdlcdrv_state *s = netdev_priv(dev);
498 	struct hdlcdrv_ioctl bi;
499 
500 	if (cmd != SIOCDEVPRIVATE) {
501 		if (s->ops && s->ops->ioctl)
502 			return s->ops->ioctl(dev, ifr, &bi, cmd);
503 		return -ENOIOCTLCMD;
504 	}
505 	if (copy_from_user(&bi, ifr->ifr_data, sizeof(bi)))
506 		return -EFAULT;
507 
508 	switch (bi.cmd) {
509 	default:
510 		if (s->ops && s->ops->ioctl)
511 			return s->ops->ioctl(dev, ifr, &bi, cmd);
512 		return -ENOIOCTLCMD;
513 
514 	case HDLCDRVCTL_GETCHANNELPAR:
515 		bi.data.cp.tx_delay = s->ch_params.tx_delay;
516 		bi.data.cp.tx_tail = s->ch_params.tx_tail;
517 		bi.data.cp.slottime = s->ch_params.slottime;
518 		bi.data.cp.ppersist = s->ch_params.ppersist;
519 		bi.data.cp.fulldup = s->ch_params.fulldup;
520 		break;
521 
522 	case HDLCDRVCTL_SETCHANNELPAR:
523 		if (!capable(CAP_NET_ADMIN))
524 			return -EACCES;
525 		s->ch_params.tx_delay = bi.data.cp.tx_delay;
526 		s->ch_params.tx_tail = bi.data.cp.tx_tail;
527 		s->ch_params.slottime = bi.data.cp.slottime;
528 		s->ch_params.ppersist = bi.data.cp.ppersist;
529 		s->ch_params.fulldup = bi.data.cp.fulldup;
530 		s->hdlctx.slotcnt = 1;
531 		return 0;
532 
533 	case HDLCDRVCTL_GETMODEMPAR:
534 		bi.data.mp.iobase = dev->base_addr;
535 		bi.data.mp.irq = dev->irq;
536 		bi.data.mp.dma = dev->dma;
537 		bi.data.mp.dma2 = s->ptt_out.dma2;
538 		bi.data.mp.seriobase = s->ptt_out.seriobase;
539 		bi.data.mp.pariobase = s->ptt_out.pariobase;
540 		bi.data.mp.midiiobase = s->ptt_out.midiiobase;
541 		break;
542 
543 	case HDLCDRVCTL_SETMODEMPAR:
544 		if ((!capable(CAP_SYS_RAWIO)) || netif_running(dev))
545 			return -EACCES;
546 		dev->base_addr = bi.data.mp.iobase;
547 		dev->irq = bi.data.mp.irq;
548 		dev->dma = bi.data.mp.dma;
549 		s->ptt_out.dma2 = bi.data.mp.dma2;
550 		s->ptt_out.seriobase = bi.data.mp.seriobase;
551 		s->ptt_out.pariobase = bi.data.mp.pariobase;
552 		s->ptt_out.midiiobase = bi.data.mp.midiiobase;
553 		return 0;
554 
555 	case HDLCDRVCTL_GETSTAT:
556 		bi.data.cs.ptt = hdlcdrv_ptt(s);
557 		bi.data.cs.dcd = s->hdlcrx.dcd;
558 		bi.data.cs.ptt_keyed = s->ptt_keyed;
559 		bi.data.cs.tx_packets = dev->stats.tx_packets;
560 		bi.data.cs.tx_errors = dev->stats.tx_errors;
561 		bi.data.cs.rx_packets = dev->stats.rx_packets;
562 		bi.data.cs.rx_errors = dev->stats.rx_errors;
563 		break;
564 
565 	case HDLCDRVCTL_OLDGETSTAT:
566 		bi.data.ocs.ptt = hdlcdrv_ptt(s);
567 		bi.data.ocs.dcd = s->hdlcrx.dcd;
568 		bi.data.ocs.ptt_keyed = s->ptt_keyed;
569 		break;
570 
571 	case HDLCDRVCTL_CALIBRATE:
572 		if(!capable(CAP_SYS_RAWIO))
573 			return -EPERM;
574 		if (bi.data.calibrate > INT_MAX / s->par.bitrate)
575 			return -EINVAL;
576 		s->hdlctx.calibrate = bi.data.calibrate * s->par.bitrate / 16;
577 		return 0;
578 
579 	case HDLCDRVCTL_GETSAMPLES:
580 #ifndef HDLCDRV_DEBUG
581 		return -EPERM;
582 #else /* HDLCDRV_DEBUG */
583 		if (s->bitbuf_channel.rd == s->bitbuf_channel.wr)
584 			return -EAGAIN;
585 		bi.data.bits =
586 			s->bitbuf_channel.buffer[s->bitbuf_channel.rd];
587 		s->bitbuf_channel.rd = (s->bitbuf_channel.rd+1) %
588 			sizeof(s->bitbuf_channel.buffer);
589 		break;
590 #endif /* HDLCDRV_DEBUG */
591 
592 	case HDLCDRVCTL_GETBITS:
593 #ifndef HDLCDRV_DEBUG
594 		return -EPERM;
595 #else /* HDLCDRV_DEBUG */
596 		if (s->bitbuf_hdlc.rd == s->bitbuf_hdlc.wr)
597 			return -EAGAIN;
598 		bi.data.bits =
599 			s->bitbuf_hdlc.buffer[s->bitbuf_hdlc.rd];
600 		s->bitbuf_hdlc.rd = (s->bitbuf_hdlc.rd+1) %
601 			sizeof(s->bitbuf_hdlc.buffer);
602 		break;
603 #endif /* HDLCDRV_DEBUG */
604 
605 	case HDLCDRVCTL_DRIVERNAME:
606 		if (s->ops && s->ops->drvname) {
607 			strncpy(bi.data.drivername, s->ops->drvname,
608 				sizeof(bi.data.drivername));
609 			break;
610 		}
611 		bi.data.drivername[0] = '\0';
612 		break;
613 
614 	}
615 	if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
616 		return -EFAULT;
617 	return 0;
618 
619 }
620 
621 /* --------------------------------------------------------------------- */
622 
623 static const struct net_device_ops hdlcdrv_netdev = {
624 	.ndo_open	= hdlcdrv_open,
625 	.ndo_stop	= hdlcdrv_close,
626 	.ndo_start_xmit = hdlcdrv_send_packet,
627 	.ndo_do_ioctl	= hdlcdrv_ioctl,
628 	.ndo_set_mac_address = hdlcdrv_set_mac_address,
629 };
630 
631 /*
632  * Initialize fields in hdlcdrv
633  */
hdlcdrv_setup(struct net_device * dev)634 static void hdlcdrv_setup(struct net_device *dev)
635 {
636 	static const struct hdlcdrv_channel_params dflt_ch_params = {
637 		20, 2, 10, 40, 0
638 	};
639 	struct hdlcdrv_state *s = netdev_priv(dev);
640 
641 	/*
642 	 * initialize the hdlcdrv_state struct
643 	 */
644 	s->ch_params = dflt_ch_params;
645 	s->ptt_keyed = 0;
646 
647 	spin_lock_init(&s->hdlcrx.hbuf.lock);
648 	s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
649 	s->hdlcrx.in_hdlc_rx = 0;
650 	s->hdlcrx.rx_state = 0;
651 
652 	spin_lock_init(&s->hdlctx.hbuf.lock);
653 	s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
654 	s->hdlctx.in_hdlc_tx = 0;
655 	s->hdlctx.tx_state = 1;
656 	s->hdlctx.numflags = 0;
657 	s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
658 	s->hdlctx.ptt = 0;
659 	s->hdlctx.slotcnt = s->ch_params.slottime;
660 	s->hdlctx.calibrate = 0;
661 
662 #ifdef HDLCDRV_DEBUG
663 	s->bitbuf_channel.rd = s->bitbuf_channel.wr = 0;
664 	s->bitbuf_channel.shreg = 0x80;
665 
666 	s->bitbuf_hdlc.rd = s->bitbuf_hdlc.wr = 0;
667 	s->bitbuf_hdlc.shreg = 0x80;
668 #endif /* HDLCDRV_DEBUG */
669 
670 
671 	/* Fill in the fields of the device structure */
672 
673 	s->skb = NULL;
674 
675 	dev->netdev_ops = &hdlcdrv_netdev;
676 	dev->header_ops = &ax25_header_ops;
677 
678 	dev->type = ARPHRD_AX25;           /* AF_AX25 device */
679 	dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
680 	dev->mtu = AX25_DEF_PACLEN;        /* eth_mtu is the default */
681 	dev->addr_len = AX25_ADDR_LEN;     /* sizeof an ax.25 address */
682 	memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
683 	memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
684 	dev->tx_queue_len = 16;
685 }
686 
687 /* --------------------------------------------------------------------- */
hdlcdrv_register(const struct hdlcdrv_ops * ops,unsigned int privsize,const char * ifname,unsigned int baseaddr,unsigned int irq,unsigned int dma)688 struct net_device *hdlcdrv_register(const struct hdlcdrv_ops *ops,
689 				    unsigned int privsize, const char *ifname,
690 				    unsigned int baseaddr, unsigned int irq,
691 				    unsigned int dma)
692 {
693 	struct net_device *dev;
694 	struct hdlcdrv_state *s;
695 	int err;
696 
697 	BUG_ON(ops == NULL);
698 
699 	if (privsize < sizeof(struct hdlcdrv_state))
700 		privsize = sizeof(struct hdlcdrv_state);
701 
702 	dev = alloc_netdev(privsize, ifname, hdlcdrv_setup);
703 	if (!dev)
704 		return ERR_PTR(-ENOMEM);
705 
706 	/*
707 	 * initialize part of the hdlcdrv_state struct
708 	 */
709 	s = netdev_priv(dev);
710 	s->magic = HDLCDRV_MAGIC;
711 	s->ops = ops;
712 	dev->base_addr = baseaddr;
713 	dev->irq = irq;
714 	dev->dma = dma;
715 
716 	err = register_netdev(dev);
717 	if (err < 0) {
718 		printk(KERN_WARNING "hdlcdrv: cannot register net "
719 		       "device %s\n", dev->name);
720 		free_netdev(dev);
721 		dev = ERR_PTR(err);
722 	}
723 	return dev;
724 }
725 
726 /* --------------------------------------------------------------------- */
727 
hdlcdrv_unregister(struct net_device * dev)728 void hdlcdrv_unregister(struct net_device *dev)
729 {
730 	struct hdlcdrv_state *s = netdev_priv(dev);
731 
732 	BUG_ON(s->magic != HDLCDRV_MAGIC);
733 
734 	if (s->opened && s->ops->close)
735 		s->ops->close(dev);
736 	unregister_netdev(dev);
737 
738 	free_netdev(dev);
739 }
740 
741 /* --------------------------------------------------------------------- */
742 
743 EXPORT_SYMBOL(hdlcdrv_receiver);
744 EXPORT_SYMBOL(hdlcdrv_transmitter);
745 EXPORT_SYMBOL(hdlcdrv_arbitrate);
746 EXPORT_SYMBOL(hdlcdrv_register);
747 EXPORT_SYMBOL(hdlcdrv_unregister);
748 
749 /* --------------------------------------------------------------------- */
750 
hdlcdrv_init_driver(void)751 static int __init hdlcdrv_init_driver(void)
752 {
753 	printk(KERN_INFO "hdlcdrv: (C) 1996-2000 Thomas Sailer HB9JNX/AE4WA\n");
754 	printk(KERN_INFO "hdlcdrv: version 0.8\n");
755 	return 0;
756 }
757 
758 /* --------------------------------------------------------------------- */
759 
hdlcdrv_cleanup_driver(void)760 static void __exit hdlcdrv_cleanup_driver(void)
761 {
762 	printk(KERN_INFO "hdlcdrv: cleanup\n");
763 }
764 
765 /* --------------------------------------------------------------------- */
766 
767 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
768 MODULE_DESCRIPTION("Packet Radio network interface HDLC encoder/decoder");
769 MODULE_LICENSE("GPL");
770 module_init(hdlcdrv_init_driver);
771 module_exit(hdlcdrv_cleanup_driver);
772 
773 /* --------------------------------------------------------------------- */
774