1 /*****************************************************************************/
4 * hdlcdrv.c -- HDLC packet radio network driver.
6 * Copyright (C) 1996-2000 Thomas Sailer (sailer@ife.ee.ethz.ch)
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.
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.
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.
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.
26 * The driver was derived from Donald Beckers skeleton.c
27 * Written 1993-94 by Donald Becker.
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
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
43 /*****************************************************************************/
45 #include <linux/module.h>
46 #include <linux/types.h>
47 #include <linux/net.h>
50 #include <linux/slab.h>
51 #include <linux/errno.h>
52 #include <linux/init.h>
53 #include <linux/bitops.h>
55 #include <linux/netdevice.h>
56 #include <linux/if_arp.h>
57 #include <linux/skbuff.h>
58 #include <linux/hdlcdrv.h>
60 #include <asm/uaccess.h>
62 #include <linux/crc-ccitt.h>
64 /* --------------------------------------------------------------------- */
68 /* --------------------------------------------------------------------- */
70 #define PARAM_TXDELAY 1
71 #define PARAM_PERSIST 2
72 #define PARAM_SLOTTIME 3
73 #define PARAM_TXTAIL 4
74 #define PARAM_FULLDUP 5
75 #define PARAM_HARDWARE 6
76 #define PARAM_RETURN 255
78 /* --------------------------------------------------------------------- */
80 * the CRC routines are stolen from WAMPES
85 /*---------------------------------------------------------------------------*/
87 static inline void append_crc_ccitt(unsigned char *buffer
, int len
)
89 unsigned int crc
= crc_ccitt(0xffff, buffer
, len
) ^ 0xffff;
94 /*---------------------------------------------------------------------------*/
96 static inline int check_crc_ccitt(const unsigned char *buf
, int cnt
)
98 return (crc_ccitt(0xffff, buf
, cnt
) & 0xffff) == 0xf0b8;
101 /*---------------------------------------------------------------------------*/
104 static int calc_crc_ccitt(const unsigned char *buf
, int cnt
)
106 unsigned int crc
= 0xffff;
108 for (; cnt
> 0; cnt
--)
109 crc
= (crc
>> 8) ^ crc_ccitt_table
[(crc
^ *buf
++) & 0xff];
111 return (crc
& 0xffff);
115 /* ---------------------------------------------------------------------- */
117 #define tenms_to_2flags(s,tenms) ((tenms * s->par.bitrate) / 100 / 16)
119 /* ---------------------------------------------------------------------- */
124 static int hdlc_rx_add_bytes(struct hdlcdrv_state
*s
, unsigned int bits
,
129 while (s
->hdlcrx
.rx_state
&& num
>= 8) {
130 if (s
->hdlcrx
.len
>= sizeof(s
->hdlcrx
.buffer
)) {
131 s
->hdlcrx
.rx_state
= 0;
134 *s
->hdlcrx
.bp
++ = bits
>> (32-num
);
142 static void hdlc_rx_flag(struct net_device
*dev
, struct hdlcdrv_state
*s
)
148 if (s
->hdlcrx
.len
< 4)
150 if (!check_crc_ccitt(s
->hdlcrx
.buffer
, s
->hdlcrx
.len
))
152 pkt_len
= s
->hdlcrx
.len
- 2 + 1; /* KISS kludge */
153 if (!(skb
= dev_alloc_skb(pkt_len
))) {
154 printk("%s: memory squeeze, dropping packet\n", dev
->name
);
155 s
->stats
.rx_dropped
++;
158 cp
= skb_put(skb
, pkt_len
);
159 *cp
++ = 0; /* KISS kludge */
160 memcpy(cp
, s
->hdlcrx
.buffer
, pkt_len
- 1);
161 skb
->protocol
= ax25_type_trans(skb
, dev
);
163 dev
->last_rx
= jiffies
;
164 s
->stats
.rx_packets
++;
167 void hdlcdrv_receiver(struct net_device
*dev
, struct hdlcdrv_state
*s
)
170 unsigned int mask1
, mask2
, mask3
, mask4
, mask5
, mask6
, word
;
172 if (!s
|| s
->magic
!= HDLCDRV_MAGIC
)
174 if (test_and_set_bit(0, &s
->hdlcrx
.in_hdlc_rx
))
177 while (!hdlcdrv_hbuf_empty(&s
->hdlcrx
.hbuf
)) {
178 word
= hdlcdrv_hbuf_get(&s
->hdlcrx
.hbuf
);
181 hdlcdrv_add_bitbuffer_word(&s
->bitbuf_hdlc
, word
);
182 #endif /* HDLCDRV_DEBUG */
183 s
->hdlcrx
.bitstream
>>= 16;
184 s
->hdlcrx
.bitstream
|= word
<< 16;
185 s
->hdlcrx
.bitbuf
>>= 16;
186 s
->hdlcrx
.bitbuf
|= word
<< 16;
187 s
->hdlcrx
.numbits
+= 16;
188 for(i
= 15, mask1
= 0x1fc00, mask2
= 0x1fe00, mask3
= 0x0fc00,
189 mask4
= 0x1f800, mask5
= 0xf800, mask6
= 0xffff;
191 i
--, mask1
<<= 1, mask2
<<= 1, mask3
<<= 1, mask4
<<= 1,
192 mask5
<<= 1, mask6
= (mask6
<< 1) | 1) {
193 if ((s
->hdlcrx
.bitstream
& mask1
) == mask1
)
194 s
->hdlcrx
.rx_state
= 0; /* abort received */
195 else if ((s
->hdlcrx
.bitstream
& mask2
) == mask3
) {
197 if (s
->hdlcrx
.rx_state
) {
198 hdlc_rx_add_bytes(s
, s
->hdlcrx
.bitbuf
202 hdlc_rx_flag(dev
, s
);
205 s
->hdlcrx
.bp
= s
->hdlcrx
.buffer
;
206 s
->hdlcrx
.rx_state
= 1;
207 s
->hdlcrx
.numbits
= i
;
208 } else if ((s
->hdlcrx
.bitstream
& mask4
) == mask5
) {
211 s
->hdlcrx
.bitbuf
= (s
->hdlcrx
.bitbuf
& (~mask6
)) |
212 ((s
->hdlcrx
.bitbuf
& mask6
) << 1);
215 s
->hdlcrx
.numbits
-= hdlc_rx_add_bytes(s
, s
->hdlcrx
.bitbuf
,
218 clear_bit(0, &s
->hdlcrx
.in_hdlc_rx
);
221 /* ---------------------------------------------------------------------- */
223 static inline void do_kiss_params(struct hdlcdrv_state
*s
,
224 unsigned char *data
, unsigned long len
)
228 #define PKP(a,b) printk(KERN_INFO "hdlcdrv.c: channel params: " a "\n", b)
229 #else /* KISS_VERBOSE */
231 #endif /* KISS_VERBOSE */
237 s
->ch_params
.tx_delay
= data
[1];
238 PKP("TX delay = %ums", 10 * s
->ch_params
.tx_delay
);
241 s
->ch_params
.ppersist
= data
[1];
242 PKP("p persistence = %u", s
->ch_params
.ppersist
);
245 s
->ch_params
.slottime
= data
[1];
246 PKP("slot time = %ums", s
->ch_params
.slottime
);
249 s
->ch_params
.tx_tail
= data
[1];
250 PKP("TX tail = %ums", s
->ch_params
.tx_tail
);
253 s
->ch_params
.fulldup
= !!data
[1];
254 PKP("%s duplex", s
->ch_params
.fulldup
? "full" : "half");
262 /* ---------------------------------------------------------------------- */
264 void hdlcdrv_transmitter(struct net_device
*dev
, struct hdlcdrv_state
*s
)
266 unsigned int mask1
, mask2
, mask3
;
271 if (!s
|| s
->magic
!= HDLCDRV_MAGIC
)
273 if (test_and_set_bit(0, &s
->hdlctx
.in_hdlc_tx
))
276 if (s
->hdlctx
.numbits
>= 16) {
277 if (hdlcdrv_hbuf_full(&s
->hdlctx
.hbuf
)) {
278 clear_bit(0, &s
->hdlctx
.in_hdlc_tx
);
281 hdlcdrv_hbuf_put(&s
->hdlctx
.hbuf
, s
->hdlctx
.bitbuf
);
282 s
->hdlctx
.bitbuf
>>= 16;
283 s
->hdlctx
.numbits
-= 16;
285 switch (s
->hdlctx
.tx_state
) {
287 clear_bit(0, &s
->hdlctx
.in_hdlc_tx
);
291 if (s
->hdlctx
.numflags
) {
292 s
->hdlctx
.numflags
--;
294 0x7e7e << s
->hdlctx
.numbits
;
295 s
->hdlctx
.numbits
+= 16;
298 if (s
->hdlctx
.tx_state
== 1) {
299 clear_bit(0, &s
->hdlctx
.in_hdlc_tx
);
302 if (!(skb
= s
->skb
)) {
303 int flgs
= tenms_to_2flags(s
, s
->ch_params
.tx_tail
);
306 s
->hdlctx
.tx_state
= 1;
307 s
->hdlctx
.numflags
= flgs
;
311 netif_wake_queue(dev
);
312 pkt_len
= skb
->len
-1; /* strip KISS byte */
313 if (pkt_len
>= HDLCDRV_MAXFLEN
|| pkt_len
< 2) {
314 s
->hdlctx
.tx_state
= 0;
315 s
->hdlctx
.numflags
= 1;
316 dev_kfree_skb_irq(skb
);
319 memcpy(s
->hdlctx
.buffer
, skb
->data
+1, pkt_len
);
320 dev_kfree_skb_irq(skb
);
321 s
->hdlctx
.bp
= s
->hdlctx
.buffer
;
322 append_crc_ccitt(s
->hdlctx
.buffer
, pkt_len
);
323 s
->hdlctx
.len
= pkt_len
+2; /* the appended CRC */
324 s
->hdlctx
.tx_state
= 2;
325 s
->hdlctx
.bitstream
= 0;
326 s
->stats
.tx_packets
++;
329 if (!s
->hdlctx
.len
) {
330 s
->hdlctx
.tx_state
= 0;
331 s
->hdlctx
.numflags
= 1;
335 s
->hdlctx
.bitbuf
|= *s
->hdlctx
.bp
<<
337 s
->hdlctx
.bitstream
>>= 8;
338 s
->hdlctx
.bitstream
|= (*s
->hdlctx
.bp
++) << 16;
341 mask3
= 0xffffffff >> (31-s
->hdlctx
.numbits
);
342 s
->hdlctx
.numbits
+= 8;
343 for(i
= 0; i
< 8; i
++, mask1
<<= 1, mask2
<<= 1,
344 mask3
= (mask3
<< 1) | 1) {
345 if ((s
->hdlctx
.bitstream
& mask1
) != mask1
)
347 s
->hdlctx
.bitstream
&= ~mask2
;
349 (s
->hdlctx
.bitbuf
& mask3
) |
353 mask3
= (mask3
<< 1) | 1;
360 /* ---------------------------------------------------------------------- */
362 static void start_tx(struct net_device
*dev
, struct hdlcdrv_state
*s
)
364 s
->hdlctx
.tx_state
= 0;
365 s
->hdlctx
.numflags
= tenms_to_2flags(s
, s
->ch_params
.tx_delay
);
366 s
->hdlctx
.bitbuf
= s
->hdlctx
.bitstream
= s
->hdlctx
.numbits
= 0;
367 hdlcdrv_transmitter(dev
, s
);
372 /* ---------------------------------------------------------------------- */
374 static unsigned short random_seed
;
376 static inline unsigned short random_num(void)
378 random_seed
= 28629 * random_seed
+ 157;
382 /* ---------------------------------------------------------------------- */
384 void hdlcdrv_arbitrate(struct net_device
*dev
, struct hdlcdrv_state
*s
)
386 if (!s
|| s
->magic
!= HDLCDRV_MAGIC
|| s
->hdlctx
.ptt
|| !s
->skb
)
388 if (s
->ch_params
.fulldup
) {
393 s
->hdlctx
.slotcnt
= s
->ch_params
.slottime
;
396 if ((--s
->hdlctx
.slotcnt
) > 0)
398 s
->hdlctx
.slotcnt
= s
->ch_params
.slottime
;
399 if ((random_num() % 256) > s
->ch_params
.ppersist
)
404 /* --------------------------------------------------------------------- */
406 * ===================== network driver interface =========================
409 static int hdlcdrv_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
411 struct hdlcdrv_state
*sm
= netdev_priv(dev
);
413 if (skb
->data
[0] != 0) {
414 do_kiss_params(sm
, skb
->data
, skb
->len
);
420 netif_stop_queue(dev
);
425 /* --------------------------------------------------------------------- */
427 static int hdlcdrv_set_mac_address(struct net_device
*dev
, void *addr
)
429 struct sockaddr
*sa
= (struct sockaddr
*)addr
;
431 /* addr is an AX.25 shifted ASCII mac address */
432 memcpy(dev
->dev_addr
, sa
->sa_data
, dev
->addr_len
);
436 /* --------------------------------------------------------------------- */
438 static struct net_device_stats
*hdlcdrv_get_stats(struct net_device
*dev
)
440 struct hdlcdrv_state
*sm
= netdev_priv(dev
);
443 * Get the current statistics. This may be called with the
444 * card open or closed.
449 /* --------------------------------------------------------------------- */
451 * Open/initialize the board. This is called (in the current kernel)
452 * sometime after booting when the 'ifconfig' program is run.
454 * This routine should set everything up anew at each open, even
455 * registers that "should" only need to be set once at boot, so that
456 * there is non-reboot way to recover if something goes wrong.
459 static int hdlcdrv_open(struct net_device
*dev
)
461 struct hdlcdrv_state
*s
= netdev_priv(dev
);
464 if (!s
->ops
|| !s
->ops
->open
)
468 * initialise some variables
471 s
->hdlcrx
.hbuf
.rd
= s
->hdlcrx
.hbuf
.wr
= 0;
472 s
->hdlcrx
.in_hdlc_rx
= 0;
473 s
->hdlcrx
.rx_state
= 0;
475 s
->hdlctx
.hbuf
.rd
= s
->hdlctx
.hbuf
.wr
= 0;
476 s
->hdlctx
.in_hdlc_tx
= 0;
477 s
->hdlctx
.tx_state
= 1;
478 s
->hdlctx
.numflags
= 0;
479 s
->hdlctx
.bitstream
= s
->hdlctx
.bitbuf
= s
->hdlctx
.numbits
= 0;
481 s
->hdlctx
.slotcnt
= s
->ch_params
.slottime
;
482 s
->hdlctx
.calibrate
= 0;
484 i
= s
->ops
->open(dev
);
487 netif_start_queue(dev
);
491 /* --------------------------------------------------------------------- */
493 * The inverse routine to hdlcdrv_open().
496 static int hdlcdrv_close(struct net_device
*dev
)
498 struct hdlcdrv_state
*s
= netdev_priv(dev
);
501 netif_stop_queue(dev
);
503 if (s
->ops
&& s
->ops
->close
)
504 i
= s
->ops
->close(dev
);
506 dev_kfree_skb(s
->skb
);
512 /* --------------------------------------------------------------------- */
514 static int hdlcdrv_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
516 struct hdlcdrv_state
*s
= netdev_priv(dev
);
517 struct hdlcdrv_ioctl bi
;
519 if (cmd
!= SIOCDEVPRIVATE
) {
520 if (s
->ops
&& s
->ops
->ioctl
)
521 return s
->ops
->ioctl(dev
, ifr
, &bi
, cmd
);
524 if (copy_from_user(&bi
, ifr
->ifr_data
, sizeof(bi
)))
529 if (s
->ops
&& s
->ops
->ioctl
)
530 return s
->ops
->ioctl(dev
, ifr
, &bi
, cmd
);
533 case HDLCDRVCTL_GETCHANNELPAR
:
534 bi
.data
.cp
.tx_delay
= s
->ch_params
.tx_delay
;
535 bi
.data
.cp
.tx_tail
= s
->ch_params
.tx_tail
;
536 bi
.data
.cp
.slottime
= s
->ch_params
.slottime
;
537 bi
.data
.cp
.ppersist
= s
->ch_params
.ppersist
;
538 bi
.data
.cp
.fulldup
= s
->ch_params
.fulldup
;
541 case HDLCDRVCTL_SETCHANNELPAR
:
542 if (!capable(CAP_NET_ADMIN
))
544 s
->ch_params
.tx_delay
= bi
.data
.cp
.tx_delay
;
545 s
->ch_params
.tx_tail
= bi
.data
.cp
.tx_tail
;
546 s
->ch_params
.slottime
= bi
.data
.cp
.slottime
;
547 s
->ch_params
.ppersist
= bi
.data
.cp
.ppersist
;
548 s
->ch_params
.fulldup
= bi
.data
.cp
.fulldup
;
549 s
->hdlctx
.slotcnt
= 1;
552 case HDLCDRVCTL_GETMODEMPAR
:
553 bi
.data
.mp
.iobase
= dev
->base_addr
;
554 bi
.data
.mp
.irq
= dev
->irq
;
555 bi
.data
.mp
.dma
= dev
->dma
;
556 bi
.data
.mp
.dma2
= s
->ptt_out
.dma2
;
557 bi
.data
.mp
.seriobase
= s
->ptt_out
.seriobase
;
558 bi
.data
.mp
.pariobase
= s
->ptt_out
.pariobase
;
559 bi
.data
.mp
.midiiobase
= s
->ptt_out
.midiiobase
;
562 case HDLCDRVCTL_SETMODEMPAR
:
563 if ((!capable(CAP_SYS_RAWIO
)) || netif_running(dev
))
565 dev
->base_addr
= bi
.data
.mp
.iobase
;
566 dev
->irq
= bi
.data
.mp
.irq
;
567 dev
->dma
= bi
.data
.mp
.dma
;
568 s
->ptt_out
.dma2
= bi
.data
.mp
.dma2
;
569 s
->ptt_out
.seriobase
= bi
.data
.mp
.seriobase
;
570 s
->ptt_out
.pariobase
= bi
.data
.mp
.pariobase
;
571 s
->ptt_out
.midiiobase
= bi
.data
.mp
.midiiobase
;
574 case HDLCDRVCTL_GETSTAT
:
575 bi
.data
.cs
.ptt
= hdlcdrv_ptt(s
);
576 bi
.data
.cs
.dcd
= s
->hdlcrx
.dcd
;
577 bi
.data
.cs
.ptt_keyed
= s
->ptt_keyed
;
578 bi
.data
.cs
.tx_packets
= s
->stats
.tx_packets
;
579 bi
.data
.cs
.tx_errors
= s
->stats
.tx_errors
;
580 bi
.data
.cs
.rx_packets
= s
->stats
.rx_packets
;
581 bi
.data
.cs
.rx_errors
= s
->stats
.rx_errors
;
584 case HDLCDRVCTL_OLDGETSTAT
:
585 bi
.data
.ocs
.ptt
= hdlcdrv_ptt(s
);
586 bi
.data
.ocs
.dcd
= s
->hdlcrx
.dcd
;
587 bi
.data
.ocs
.ptt_keyed
= s
->ptt_keyed
;
590 case HDLCDRVCTL_CALIBRATE
:
591 if(!capable(CAP_SYS_RAWIO
))
593 s
->hdlctx
.calibrate
= bi
.data
.calibrate
* s
->par
.bitrate
/ 16;
596 case HDLCDRVCTL_GETSAMPLES
:
597 #ifndef HDLCDRV_DEBUG
599 #else /* HDLCDRV_DEBUG */
600 if (s
->bitbuf_channel
.rd
== s
->bitbuf_channel
.wr
)
603 s
->bitbuf_channel
.buffer
[s
->bitbuf_channel
.rd
];
604 s
->bitbuf_channel
.rd
= (s
->bitbuf_channel
.rd
+1) %
605 sizeof(s
->bitbuf_channel
.buffer
);
607 #endif /* HDLCDRV_DEBUG */
609 case HDLCDRVCTL_GETBITS
:
610 #ifndef HDLCDRV_DEBUG
612 #else /* HDLCDRV_DEBUG */
613 if (s
->bitbuf_hdlc
.rd
== s
->bitbuf_hdlc
.wr
)
616 s
->bitbuf_hdlc
.buffer
[s
->bitbuf_hdlc
.rd
];
617 s
->bitbuf_hdlc
.rd
= (s
->bitbuf_hdlc
.rd
+1) %
618 sizeof(s
->bitbuf_hdlc
.buffer
);
620 #endif /* HDLCDRV_DEBUG */
622 case HDLCDRVCTL_DRIVERNAME
:
623 if (s
->ops
&& s
->ops
->drvname
) {
624 strncpy(bi
.data
.drivername
, s
->ops
->drvname
,
625 sizeof(bi
.data
.drivername
));
628 bi
.data
.drivername
[0] = '\0';
632 if (copy_to_user(ifr
->ifr_data
, &bi
, sizeof(bi
)))
638 /* --------------------------------------------------------------------- */
641 * Initialize fields in hdlcdrv
643 static void hdlcdrv_setup(struct net_device
*dev
)
645 static const struct hdlcdrv_channel_params dflt_ch_params
= {
648 struct hdlcdrv_state
*s
= netdev_priv(dev
);
651 * initialize the hdlcdrv_state struct
653 s
->ch_params
= dflt_ch_params
;
656 spin_lock_init(&s
->hdlcrx
.hbuf
.lock
);
657 s
->hdlcrx
.hbuf
.rd
= s
->hdlcrx
.hbuf
.wr
= 0;
658 s
->hdlcrx
.in_hdlc_rx
= 0;
659 s
->hdlcrx
.rx_state
= 0;
661 spin_lock_init(&s
->hdlctx
.hbuf
.lock
);
662 s
->hdlctx
.hbuf
.rd
= s
->hdlctx
.hbuf
.wr
= 0;
663 s
->hdlctx
.in_hdlc_tx
= 0;
664 s
->hdlctx
.tx_state
= 1;
665 s
->hdlctx
.numflags
= 0;
666 s
->hdlctx
.bitstream
= s
->hdlctx
.bitbuf
= s
->hdlctx
.numbits
= 0;
668 s
->hdlctx
.slotcnt
= s
->ch_params
.slottime
;
669 s
->hdlctx
.calibrate
= 0;
672 s
->bitbuf_channel
.rd
= s
->bitbuf_channel
.wr
= 0;
673 s
->bitbuf_channel
.shreg
= 0x80;
675 s
->bitbuf_hdlc
.rd
= s
->bitbuf_hdlc
.wr
= 0;
676 s
->bitbuf_hdlc
.shreg
= 0x80;
677 #endif /* HDLCDRV_DEBUG */
680 * initialize the device struct
682 dev
->open
= hdlcdrv_open
;
683 dev
->stop
= hdlcdrv_close
;
684 dev
->do_ioctl
= hdlcdrv_ioctl
;
685 dev
->hard_start_xmit
= hdlcdrv_send_packet
;
686 dev
->get_stats
= hdlcdrv_get_stats
;
688 /* Fill in the fields of the device structure */
692 dev
->hard_header
= ax25_hard_header
;
693 dev
->rebuild_header
= ax25_rebuild_header
;
694 dev
->set_mac_address
= hdlcdrv_set_mac_address
;
696 dev
->type
= ARPHRD_AX25
; /* AF_AX25 device */
697 dev
->hard_header_len
= AX25_MAX_HEADER_LEN
+ AX25_BPQ_HEADER_LEN
;
698 dev
->mtu
= AX25_DEF_PACLEN
; /* eth_mtu is the default */
699 dev
->addr_len
= AX25_ADDR_LEN
; /* sizeof an ax.25 address */
700 memcpy(dev
->broadcast
, &ax25_bcast
, AX25_ADDR_LEN
);
701 memcpy(dev
->dev_addr
, &ax25_defaddr
, AX25_ADDR_LEN
);
702 dev
->tx_queue_len
= 16;
705 /* --------------------------------------------------------------------- */
706 struct net_device
*hdlcdrv_register(const struct hdlcdrv_ops
*ops
,
707 unsigned int privsize
, const char *ifname
,
708 unsigned int baseaddr
, unsigned int irq
,
711 struct net_device
*dev
;
712 struct hdlcdrv_state
*s
;
717 if (privsize
< sizeof(struct hdlcdrv_state
))
718 privsize
= sizeof(struct hdlcdrv_state
);
720 dev
= alloc_netdev(privsize
, ifname
, hdlcdrv_setup
);
722 return ERR_PTR(-ENOMEM
);
725 * initialize part of the hdlcdrv_state struct
727 s
= netdev_priv(dev
);
728 s
->magic
= HDLCDRV_MAGIC
;
730 dev
->base_addr
= baseaddr
;
734 err
= register_netdev(dev
);
736 printk(KERN_WARNING
"hdlcdrv: cannot register net "
737 "device %s\n", dev
->name
);
744 /* --------------------------------------------------------------------- */
746 void hdlcdrv_unregister(struct net_device
*dev
)
748 struct hdlcdrv_state
*s
= netdev_priv(dev
);
750 BUG_ON(s
->magic
!= HDLCDRV_MAGIC
);
752 if (s
->opened
&& s
->ops
->close
)
754 unregister_netdev(dev
);
759 /* --------------------------------------------------------------------- */
761 EXPORT_SYMBOL(hdlcdrv_receiver
);
762 EXPORT_SYMBOL(hdlcdrv_transmitter
);
763 EXPORT_SYMBOL(hdlcdrv_arbitrate
);
764 EXPORT_SYMBOL(hdlcdrv_register
);
765 EXPORT_SYMBOL(hdlcdrv_unregister
);
767 /* --------------------------------------------------------------------- */
769 static int __init
hdlcdrv_init_driver(void)
771 printk(KERN_INFO
"hdlcdrv: (C) 1996-2000 Thomas Sailer HB9JNX/AE4WA\n");
772 printk(KERN_INFO
"hdlcdrv: version 0.8 compiled " __TIME__
" " __DATE__
"\n");
776 /* --------------------------------------------------------------------- */
778 static void __exit
hdlcdrv_cleanup_driver(void)
780 printk(KERN_INFO
"hdlcdrv: cleanup\n");
783 /* --------------------------------------------------------------------- */
785 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
786 MODULE_DESCRIPTION("Packet Radio network interface HDLC encoder/decoder");
787 MODULE_LICENSE("GPL");
788 module_init(hdlcdrv_init_driver
);
789 module_exit(hdlcdrv_cleanup_driver
);
791 /* --------------------------------------------------------------------- */