1 /*****************************************************************************/
4 * baycom_epp.c -- baycom epp radio modem driver.
6 * Copyright (C) 1998-2000
7 * Thomas Sailer (sailer@ife.ee.ethz.ch)
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 * Please note that the GPL allows you to use the driver, NOT the radio.
24 * In order to use the radio, you need a license from the communications
25 * authority of your country.
29 * 0.1 xx.xx.1998 Initial version by Matthias Welwarsky (dg2fef)
30 * 0.2 21.04.1998 Massive rework by Thomas Sailer
31 * Integrated FPGA EPP modem configuration routines
32 * 0.3 11.05.1998 Took FPGA config out and moved it into a separate program
33 * 0.4 26.07.1999 Adapted to new lowlevel parport driver interface
34 * 0.5 03.08.1999 adapt to Linus' new __setup/__initcall
35 * removed some pre-2.2 kernel compatibility cruft
36 * 0.6 10.08.1999 Check if parport can do SPP and is safe to access during interrupt contexts
37 * 0.7 12.02.2000 adapted to softnet driver interface
41 /*****************************************************************************/
43 #include <linux/config.h>
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/init.h>
47 #include <linux/string.h>
48 #include <linux/workqueue.h>
50 #include <linux/parport.h>
51 #include <linux/smp_lock.h>
52 #include <asm/uaccess.h>
53 #include <linux/if_arp.h>
54 #include <linux/kmod.h>
55 #include <linux/hdlcdrv.h>
56 #include <linux/baycom.h>
57 #include <linux/jiffies.h>
58 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
59 /* prototypes for ax25_encapsulate and ax25_rebuild_header */
61 #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
62 #include <linux/crc-ccitt.h>
64 /* --------------------------------------------------------------------- */
67 #define BAYCOM_MAGIC 19730510
69 /* --------------------------------------------------------------------- */
71 static const char paranoia_str
[] = KERN_ERR
72 "baycom_epp: bad magic number for hdlcdrv_state struct in routine %s\n";
74 static const char bc_drvname
[] = "baycom_epp";
75 static const char bc_drvinfo
[] = KERN_INFO
"baycom_epp: (C) 1998-2000 Thomas Sailer, HB9JNX/AE4WA\n"
76 KERN_INFO
"baycom_epp: version 0.7 compiled " __TIME__
" " __DATE__
"\n";
78 /* --------------------------------------------------------------------- */
82 static struct net_device
*baycom_device
[NR_PORTS
];
84 /* --------------------------------------------------------------------- */
86 /* EPP status register */
87 #define EPP_DCDBIT 0x80
88 #define EPP_PTTBIT 0x08
90 #define EPP_NRAEF 0x02
93 #define EPP_NTAEF 0x10
94 #define EPP_NTEF EPP_PTTBIT
96 /* EPP control register */
97 #define EPP_TX_FIFO_ENABLE 0x10
98 #define EPP_RX_FIFO_ENABLE 0x08
99 #define EPP_MODEM_ENABLE 0x20
100 #define EPP_LEDS 0xC0
101 #define EPP_IRQ_ENABLE 0x10
104 #define LPTREG_ECONTROL 0x402
105 #define LPTREG_CONFIGB 0x401
106 #define LPTREG_CONFIGA 0x400
107 #define LPTREG_EPPDATA 0x004
108 #define LPTREG_EPPADDR 0x003
109 #define LPTREG_CONTROL 0x002
110 #define LPTREG_STATUS 0x001
111 #define LPTREG_DATA 0x000
113 /* LPT control register */
114 #define LPTCTRL_PROGRAM 0x04 /* 0 to reprogram */
115 #define LPTCTRL_WRITE 0x01
116 #define LPTCTRL_ADDRSTB 0x08
117 #define LPTCTRL_DATASTB 0x02
118 #define LPTCTRL_INTEN 0x10
120 /* LPT status register */
121 #define LPTSTAT_SHIFT_NINTR 6
122 #define LPTSTAT_WAIT 0x80
123 #define LPTSTAT_NINTR (1<<LPTSTAT_SHIFT_NINTR)
124 #define LPTSTAT_PE 0x20
125 #define LPTSTAT_DONE 0x10
126 #define LPTSTAT_NERROR 0x08
127 #define LPTSTAT_EPPTIMEOUT 0x01
129 /* LPT data register */
130 #define LPTDATA_SHIFT_TDI 0
131 #define LPTDATA_SHIFT_TMS 2
132 #define LPTDATA_TDI (1<<LPTDATA_SHIFT_TDI)
133 #define LPTDATA_TCK 0x02
134 #define LPTDATA_TMS (1<<LPTDATA_SHIFT_TMS)
135 #define LPTDATA_INITBIAS 0x80
138 /* EPP modem config/status bits */
139 #define EPP_DCDBIT 0x80
140 #define EPP_PTTBIT 0x08
141 #define EPP_RXEBIT 0x01
142 #define EPP_RXAEBIT 0x02
143 #define EPP_RXHFULL 0x04
145 #define EPP_NTHF 0x20
146 #define EPP_NTAEF 0x10
147 #define EPP_NTEF EPP_PTTBIT
149 #define EPP_TX_FIFO_ENABLE 0x10
150 #define EPP_RX_FIFO_ENABLE 0x08
151 #define EPP_MODEM_ENABLE 0x20
152 #define EPP_LEDS 0xC0
153 #define EPP_IRQ_ENABLE 0x10
155 /* Xilinx 4k JTAG instructions */
156 #define XC4K_IRLENGTH 3
157 #define XC4K_EXTEST 0
158 #define XC4K_PRELOAD 1
159 #define XC4K_CONFIGURE 5
160 #define XC4K_BYPASS 7
162 #define EPP_CONVENTIONAL 0
164 #define EPP_FPGAEXTSTATUS 2
166 #define TXBUFFER_SIZE ((HDLCDRV_MAXFLEN*6/5)+8)
168 /* ---------------------------------------------------------------------- */
170 * Information that need to be kept for each board.
173 struct baycom_state
{
176 struct pardevice
*pdev
;
177 unsigned int work_running
;
178 struct work_struct run_work
;
180 unsigned int bitrate
;
187 unsigned int extmodem
;
188 unsigned int loopback
;
191 struct hdlcdrv_channel_params ch_params
;
194 unsigned int bitbuf
, bitstream
, numbits
, state
;
195 unsigned char *bufptr
;
197 unsigned char buf
[TXBUFFER_SIZE
];
204 enum { tx_idle
= 0, tx_keyup
, tx_data
, tx_tail
} state
;
205 unsigned char *bufptr
;
207 unsigned char buf
[TXBUFFER_SIZE
];
210 struct net_device_stats stats
;
211 unsigned int ptt_keyed
;
212 struct sk_buff
*skb
; /* next transmit packet */
216 unsigned long last_jiffies
;
218 unsigned last_intcnt
;
221 unsigned int mod_cycles
;
222 unsigned int demod_cycles
;
224 #endif /* BAYCOM_DEBUG */
227 /* --------------------------------------------------------------------- */
231 /* --------------------------------------------------------------------- */
233 #define PARAM_TXDELAY 1
234 #define PARAM_PERSIST 2
235 #define PARAM_SLOTTIME 3
236 #define PARAM_TXTAIL 4
237 #define PARAM_FULLDUP 5
238 #define PARAM_HARDWARE 6
239 #define PARAM_RETURN 255
241 /* --------------------------------------------------------------------- */
243 * the CRC routines are stolen from WAMPES
248 /*---------------------------------------------------------------------------*/
251 static inline void append_crc_ccitt(unsigned char *buffer
, int len
)
253 unsigned int crc
= 0xffff;
256 crc
= (crc
>> 8) ^ crc_ccitt_table
[(crc
^ *buffer
++) & 0xff];
259 *buffer
++ = crc
>> 8;
263 /*---------------------------------------------------------------------------*/
265 static inline int check_crc_ccitt(const unsigned char *buf
, int cnt
)
267 return (crc_ccitt(0xffff, buf
, cnt
) & 0xffff) == 0xf0b8;
270 /*---------------------------------------------------------------------------*/
272 static inline int calc_crc_ccitt(const unsigned char *buf
, int cnt
)
274 return (crc_ccitt(0xffff, buf
, cnt
) ^ 0xffff) & 0xffff;
277 /* ---------------------------------------------------------------------- */
279 #define tenms_to_flags(bc,tenms) ((tenms * bc->bitrate) / 800)
281 /* --------------------------------------------------------------------- */
283 static inline void baycom_int_freq(struct baycom_state
*bc
)
286 unsigned long cur_jiffies
= jiffies
;
288 * measure the interrupt frequency
290 bc
->debug_vals
.cur_intcnt
++;
291 if (time_after_eq(cur_jiffies
, bc
->debug_vals
.last_jiffies
+ HZ
)) {
292 bc
->debug_vals
.last_jiffies
= cur_jiffies
;
293 bc
->debug_vals
.last_intcnt
= bc
->debug_vals
.cur_intcnt
;
294 bc
->debug_vals
.cur_intcnt
= 0;
295 bc
->debug_vals
.last_pllcorr
= bc
->debug_vals
.cur_pllcorr
;
296 bc
->debug_vals
.cur_pllcorr
= 0;
298 #endif /* BAYCOM_DEBUG */
301 /* ---------------------------------------------------------------------- */
303 * eppconfig_path should be setable via /proc/sys.
306 static char eppconfig_path
[256] = "/usr/sbin/eppfpga";
308 static char *envp
[] = { "HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL
};
310 /* eppconfig: called during ifconfig up to configure the modem */
311 static int eppconfig(struct baycom_state
*bc
)
315 char *argv
[] = { eppconfig_path
, "-s", "-p", portarg
, "-m", modearg
,
318 /* set up arguments */
319 sprintf(modearg
, "%sclk,%smodem,fclk=%d,bps=%d,divider=%d%s,extstat",
320 bc
->cfg
.intclk
? "int" : "ext",
321 bc
->cfg
.extmodem
? "ext" : "int", bc
->cfg
.fclk
, bc
->cfg
.bps
,
322 (bc
->cfg
.fclk
+ 8 * bc
->cfg
.bps
) / (16 * bc
->cfg
.bps
),
323 bc
->cfg
.loopback
? ",loopback" : "");
324 sprintf(portarg
, "%ld", bc
->pdev
->port
->base
);
325 printk(KERN_DEBUG
"%s: %s -s -p %s -m %s\n", bc_drvname
, eppconfig_path
, portarg
, modearg
);
327 return call_usermodehelper(eppconfig_path
, argv
, envp
, 1);
330 /* ---------------------------------------------------------------------- */
332 static void epp_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
336 /* ---------------------------------------------------------------------- */
338 static inline void do_kiss_params(struct baycom_state
*bc
,
339 unsigned char *data
, unsigned long len
)
343 #define PKP(a,b) printk(KERN_INFO "baycomm_epp: channel params: " a "\n", b)
344 #else /* KISS_VERBOSE */
346 #endif /* KISS_VERBOSE */
352 bc
->ch_params
.tx_delay
= data
[1];
353 PKP("TX delay = %ums", 10 * bc
->ch_params
.tx_delay
);
356 bc
->ch_params
.ppersist
= data
[1];
357 PKP("p persistence = %u", bc
->ch_params
.ppersist
);
360 bc
->ch_params
.slottime
= data
[1];
361 PKP("slot time = %ums", bc
->ch_params
.slottime
);
364 bc
->ch_params
.tx_tail
= data
[1];
365 PKP("TX tail = %ums", bc
->ch_params
.tx_tail
);
368 bc
->ch_params
.fulldup
= !!data
[1];
369 PKP("%s duplex", bc
->ch_params
.fulldup
? "full" : "half");
377 /* --------------------------------------------------------------------- */
379 static void encode_hdlc(struct baycom_state
*bc
)
382 unsigned char *wp
, *bp
;
384 unsigned bitstream
, notbitstream
, bitbuf
, numbit
, crc
;
385 unsigned char crcarr
[2];
388 if (bc
->hdlctx
.bufcnt
> 0)
394 pkt_len
= skb
->len
-1; /* strip KISS byte */
397 crc
= calc_crc_ccitt(bp
, pkt_len
);
399 crcarr
[1] = crc
>> 8;
401 bitstream
= bitbuf
= numbit
= 0;
402 while (pkt_len
> -2) {
404 bitstream
|= ((unsigned int)*bp
) << 8;
405 bitbuf
|= ((unsigned int)*bp
) << numbit
;
406 notbitstream
= ~bitstream
;
411 for (j
= 0; j
< 8; j
++)
412 if (unlikely(!(notbitstream
& (0x1f0 << j
)))) {
413 bitstream
&= ~(0x100 << j
);
414 bitbuf
= (bitbuf
& (((2 << j
) << numbit
) - 1)) |
415 ((bitbuf
& ~(((2 << j
) << numbit
) - 1)) << 1);
417 notbitstream
= ~bitstream
;
420 while (numbit
>= 8) {
426 bitbuf
|= 0x7e7e << numbit
;
428 while (numbit
>= 8) {
433 bc
->hdlctx
.bufptr
= bc
->hdlctx
.buf
;
434 bc
->hdlctx
.bufcnt
= wp
- bc
->hdlctx
.buf
;
436 bc
->stats
.tx_packets
++;
439 /* ---------------------------------------------------------------------- */
441 static unsigned short random_seed
;
443 static inline unsigned short random_num(void)
445 random_seed
= 28629 * random_seed
+ 157;
449 /* ---------------------------------------------------------------------- */
451 static int transmit(struct baycom_state
*bc
, int cnt
, unsigned char stat
)
453 struct parport
*pp
= bc
->pdev
->port
;
454 unsigned char tmp
[128];
457 if (bc
->hdlctx
.state
== tx_tail
&& !(stat
& EPP_PTTBIT
))
458 bc
->hdlctx
.state
= tx_idle
;
459 if (bc
->hdlctx
.state
== tx_idle
&& bc
->hdlctx
.calibrate
<= 0) {
460 if (bc
->hdlctx
.bufcnt
<= 0)
462 if (bc
->hdlctx
.bufcnt
<= 0)
464 if (!bc
->ch_params
.fulldup
) {
465 if (!(stat
& EPP_DCDBIT
)) {
466 bc
->hdlctx
.slotcnt
= bc
->ch_params
.slottime
;
469 if ((--bc
->hdlctx
.slotcnt
) > 0)
471 bc
->hdlctx
.slotcnt
= bc
->ch_params
.slottime
;
472 if ((random_num() % 256) > bc
->ch_params
.ppersist
)
476 if (bc
->hdlctx
.state
== tx_idle
&& bc
->hdlctx
.bufcnt
> 0) {
477 bc
->hdlctx
.state
= tx_keyup
;
478 bc
->hdlctx
.flags
= tenms_to_flags(bc
, bc
->ch_params
.tx_delay
);
482 switch (bc
->hdlctx
.state
) {
484 i
= min_t(int, cnt
, bc
->hdlctx
.flags
);
486 bc
->hdlctx
.flags
-= i
;
487 if (bc
->hdlctx
.flags
<= 0)
488 bc
->hdlctx
.state
= tx_data
;
489 memset(tmp
, 0x7e, sizeof(tmp
));
491 j
= (i
> sizeof(tmp
)) ? sizeof(tmp
) : i
;
492 if (j
!= pp
->ops
->epp_write_data(pp
, tmp
, j
, 0))
499 if (bc
->hdlctx
.bufcnt
<= 0) {
501 if (bc
->hdlctx
.bufcnt
<= 0) {
502 bc
->hdlctx
.state
= tx_tail
;
503 bc
->hdlctx
.flags
= tenms_to_flags(bc
, bc
->ch_params
.tx_tail
);
507 i
= min_t(int, cnt
, bc
->hdlctx
.bufcnt
);
508 bc
->hdlctx
.bufcnt
-= i
;
510 if (i
!= pp
->ops
->epp_write_data(pp
, bc
->hdlctx
.bufptr
, i
, 0))
512 bc
->hdlctx
.bufptr
+= i
;
517 if (bc
->hdlctx
.bufcnt
> 0) {
518 bc
->hdlctx
.state
= tx_data
;
521 i
= min_t(int, cnt
, bc
->hdlctx
.flags
);
524 bc
->hdlctx
.flags
-= i
;
525 memset(tmp
, 0x7e, sizeof(tmp
));
527 j
= (i
> sizeof(tmp
)) ? sizeof(tmp
) : i
;
528 if (j
!= pp
->ops
->epp_write_data(pp
, tmp
, j
, 0))
535 default: /* fall through */
536 if (bc
->hdlctx
.calibrate
<= 0)
538 i
= min_t(int, cnt
, bc
->hdlctx
.calibrate
);
540 bc
->hdlctx
.calibrate
-= i
;
541 memset(tmp
, 0, sizeof(tmp
));
543 j
= (i
> sizeof(tmp
)) ? sizeof(tmp
) : i
;
544 if (j
!= pp
->ops
->epp_write_data(pp
, tmp
, j
, 0))
554 /* ---------------------------------------------------------------------- */
556 static void do_rxpacket(struct net_device
*dev
)
558 struct baycom_state
*bc
= netdev_priv(dev
);
563 if (bc
->hdlcrx
.bufcnt
< 4)
565 if (!check_crc_ccitt(bc
->hdlcrx
.buf
, bc
->hdlcrx
.bufcnt
))
567 pktlen
= bc
->hdlcrx
.bufcnt
-2+1; /* KISS kludge */
568 if (!(skb
= dev_alloc_skb(pktlen
))) {
569 printk("%s: memory squeeze, dropping packet\n", dev
->name
);
570 bc
->stats
.rx_dropped
++;
573 cp
= skb_put(skb
, pktlen
);
574 *cp
++ = 0; /* KISS kludge */
575 memcpy(cp
, bc
->hdlcrx
.buf
, pktlen
- 1);
576 skb
->protocol
= ax25_type_trans(skb
, dev
);
578 dev
->last_rx
= jiffies
;
579 bc
->stats
.rx_packets
++;
582 static int receive(struct net_device
*dev
, int cnt
)
584 struct baycom_state
*bc
= netdev_priv(dev
);
585 struct parport
*pp
= bc
->pdev
->port
;
586 unsigned int bitbuf
, notbitstream
, bitstream
, numbits
, state
;
587 unsigned char tmp
[128];
592 numbits
= bc
->hdlcrx
.numbits
;
593 state
= bc
->hdlcrx
.state
;
594 bitstream
= bc
->hdlcrx
.bitstream
;
595 bitbuf
= bc
->hdlcrx
.bitbuf
;
597 cnt2
= (cnt
> sizeof(tmp
)) ? sizeof(tmp
) : cnt
;
599 if (cnt2
!= pp
->ops
->epp_read_data(pp
, tmp
, cnt2
, 0)) {
604 for (; cnt2
> 0; cnt2
--, cp
++) {
606 bitstream
|= (*cp
) << 8;
608 bitbuf
|= (*cp
) << 8;
610 notbitstream
= ~bitstream
;
611 for (j
= 0; j
< 8; j
++) {
614 if (unlikely(!(notbitstream
& (0x0fc << j
)))) {
617 if (!(notbitstream
& (0x1fc << j
)))
620 /* not flag received */
621 else if (!(bitstream
& (0x1fe << j
)) != (0x0fc << j
)) {
624 bc
->hdlcrx
.bufcnt
= 0;
625 bc
->hdlcrx
.bufptr
= bc
->hdlcrx
.buf
;
632 else if (unlikely((bitstream
& (0x1f8 << j
)) == (0xf8 << j
))) {
634 bitbuf
= (bitbuf
& ((~0xff) << j
)) | ((bitbuf
& ~((~0xff) << j
)) << 1);
637 while (state
&& numbits
>= 8) {
638 if (bc
->hdlcrx
.bufcnt
>= TXBUFFER_SIZE
) {
641 *(bc
->hdlcrx
.bufptr
)++ = bitbuf
>> (16-numbits
);
648 bc
->hdlcrx
.numbits
= numbits
;
649 bc
->hdlcrx
.state
= state
;
650 bc
->hdlcrx
.bitstream
= bitstream
;
651 bc
->hdlcrx
.bitbuf
= bitbuf
;
655 /* --------------------------------------------------------------------- */
666 #endif /* __i386__ */
668 static void epp_bh(struct net_device
*dev
)
670 struct baycom_state
*bc
;
673 unsigned char tmp
[2];
674 unsigned int time1
= 0, time2
= 0, time3
= 0;
677 bc
= netdev_priv(dev
);
678 if (!bc
->work_running
)
683 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
686 bc
->debug_vals
.last_pllcorr
= stat
;
688 if (bc
->modem
== EPP_FPGAEXTSTATUS
) {
689 /* get input count */
690 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
|1;
691 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
693 if (pp
->ops
->epp_read_addr(pp
, tmp
, 2, 0) != 2)
695 cnt
= tmp
[0] | (tmp
[1] << 8);
697 /* get output count */
698 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
|2;
699 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
701 if (pp
->ops
->epp_read_addr(pp
, tmp
, 2, 0) != 2)
703 cnt2
= tmp
[0] | (tmp
[1] << 8);
704 cnt2
= 16384 - (cnt2
& 0x7fff);
705 /* return to normal */
706 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
;
707 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
709 if (transmit(bc
, cnt2
, stat
))
712 if (receive(dev
, cnt
))
714 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
719 switch (stat
& (EPP_NTAEF
|EPP_NTHF
)) {
736 if (transmit(bc
, cnt
, stat
))
740 while ((stat
& (EPP_NRAEF
|EPP_NRHF
)) != EPP_NRHF
) {
741 switch (stat
& (EPP_NRAEF
|EPP_NRHF
)) {
754 if (receive(dev
, cnt
))
756 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
760 if (bc
->bitrate
< 50000)
762 else if (bc
->bitrate
< 100000)
764 while (cnt
> 0 && stat
& EPP_NREF
) {
768 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
774 bc
->debug_vals
.mod_cycles
= time2
- time1
;
775 bc
->debug_vals
.demod_cycles
= time3
- time2
;
776 #endif /* BAYCOM_DEBUG */
777 schedule_delayed_work(&bc
->run_work
, 1);
779 netif_wake_queue(dev
);
782 printk(KERN_ERR
"%s: EPP timeout!\n", bc_drvname
);
785 /* ---------------------------------------------------------------------- */
787 * ===================== network driver interface =========================
790 static int baycom_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
792 struct baycom_state
*bc
= netdev_priv(dev
);
794 if (skb
->data
[0] != 0) {
795 do_kiss_params(bc
, skb
->data
, skb
->len
);
801 /* strip KISS byte */
802 if (skb
->len
>= HDLCDRV_MAXFLEN
+1 || skb
->len
< 3) {
806 netif_stop_queue(dev
);
811 /* --------------------------------------------------------------------- */
813 static int baycom_set_mac_address(struct net_device
*dev
, void *addr
)
815 struct sockaddr
*sa
= (struct sockaddr
*)addr
;
817 /* addr is an AX.25 shifted ASCII mac address */
818 memcpy(dev
->dev_addr
, sa
->sa_data
, dev
->addr_len
);
822 /* --------------------------------------------------------------------- */
824 static struct net_device_stats
*baycom_get_stats(struct net_device
*dev
)
826 struct baycom_state
*bc
= netdev_priv(dev
);
829 * Get the current statistics. This may be called with the
830 * card open or closed.
835 /* --------------------------------------------------------------------- */
837 static void epp_wakeup(void *handle
)
839 struct net_device
*dev
= (struct net_device
*)handle
;
840 struct baycom_state
*bc
= netdev_priv(dev
);
842 printk(KERN_DEBUG
"baycom_epp: %s: why am I being woken up?\n", dev
->name
);
843 if (!parport_claim(bc
->pdev
))
844 printk(KERN_DEBUG
"baycom_epp: %s: I'm broken.\n", dev
->name
);
847 /* --------------------------------------------------------------------- */
850 * Open/initialize the board. This is called (in the current kernel)
851 * sometime after booting when the 'ifconfig' program is run.
853 * This routine should set everything up anew at each open, even
854 * registers that "should" only need to be set once at boot, so that
855 * there is non-reboot way to recover if something goes wrong.
858 static int epp_open(struct net_device
*dev
)
860 struct baycom_state
*bc
= netdev_priv(dev
);
861 struct parport
*pp
= parport_find_base(dev
->base_addr
);
863 unsigned char tmp
[128];
865 unsigned long tstart
;
868 printk(KERN_ERR
"%s: parport at 0x%lx unknown\n", bc_drvname
, dev
->base_addr
);
873 printk(KERN_ERR
"%s: parport at 0x%lx has no irq\n", bc_drvname
, pp
->base
);
874 parport_put_port(pp
);
878 if ((~pp
->modes
) & (PARPORT_MODE_TRISTATE
| PARPORT_MODE_PCSPP
| PARPORT_MODE_SAFEININT
)) {
879 printk(KERN_ERR
"%s: parport at 0x%lx cannot be used\n",
880 bc_drvname
, pp
->base
);
881 parport_put_port(pp
);
884 memset(&bc
->modem
, 0, sizeof(bc
->modem
));
885 bc
->pdev
= parport_register_device(pp
, dev
->name
, NULL
, epp_wakeup
,
886 epp_interrupt
, PARPORT_DEV_EXCL
, dev
);
887 parport_put_port(pp
);
889 printk(KERN_ERR
"%s: cannot register parport at 0x%lx\n", bc_drvname
, pp
->base
);
892 if (parport_claim(bc
->pdev
)) {
893 printk(KERN_ERR
"%s: parport at 0x%lx busy\n", bc_drvname
, pp
->base
);
894 parport_unregister_device(bc
->pdev
);
897 dev
->irq
= /*pp->irq*/ 0;
898 INIT_WORK(&bc
->run_work
, (void *)(void *)epp_bh
, dev
);
899 bc
->work_running
= 1;
900 bc
->modem
= EPP_CONVENTIONAL
;
902 printk(KERN_INFO
"%s: no FPGA detected, assuming conventional EPP modem\n", bc_drvname
);
904 bc
->modem
= /*EPP_FPGA*/ EPP_FPGAEXTSTATUS
;
905 parport_write_control(pp
, LPTCTRL_PROGRAM
); /* prepare EPP mode; we aren't using interrupts */
906 /* reset the modem */
908 tmp
[1] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
;
909 if (pp
->ops
->epp_write_addr(pp
, tmp
, 2, 0) != 2)
911 /* autoprobe baud rate */
914 while ((signed)(jiffies
-tstart
-HZ
/3) < 0) {
915 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
917 if ((stat
& (EPP_NRAEF
|EPP_NRHF
)) == EPP_NRHF
) {
921 if (pp
->ops
->epp_read_data(pp
, tmp
, 128, 0) != 128)
923 if (pp
->ops
->epp_read_data(pp
, tmp
, 128, 0) != 128)
927 for (j
= 0; j
< 256; j
++) {
928 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
930 if (!(stat
& EPP_NREF
))
932 if (pp
->ops
->epp_read_data(pp
, tmp
, 1, 0) != 1)
936 tstart
= jiffies
- tstart
;
937 bc
->bitrate
= i
* (8 * HZ
) / tstart
;
939 i
= bc
->bitrate
>> 3;
940 while (j
< 7 && i
> 150) {
944 printk(KERN_INFO
"%s: autoprobed bitrate: %d int divider: %d int rate: %d\n",
945 bc_drvname
, bc
->bitrate
, j
, bc
->bitrate
>> (j
+2));
946 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
/*|j*/;
947 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
950 * initialise hdlc variables
952 bc
->hdlcrx
.state
= 0;
953 bc
->hdlcrx
.numbits
= 0;
954 bc
->hdlctx
.state
= tx_idle
;
955 bc
->hdlctx
.bufcnt
= 0;
956 bc
->hdlctx
.slotcnt
= bc
->ch_params
.slottime
;
957 bc
->hdlctx
.calibrate
= 0;
958 /* start the bottom half stuff */
959 schedule_delayed_work(&bc
->run_work
, 1);
960 netif_start_queue(dev
);
964 printk(KERN_ERR
"%s: epp timeout during bitrate probe\n", bc_drvname
);
965 parport_write_control(pp
, 0); /* reset the adapter */
966 parport_release(bc
->pdev
);
967 parport_unregister_device(bc
->pdev
);
971 /* --------------------------------------------------------------------- */
973 static int epp_close(struct net_device
*dev
)
975 struct baycom_state
*bc
= netdev_priv(dev
);
976 struct parport
*pp
= bc
->pdev
->port
;
977 unsigned char tmp
[1];
979 bc
->work_running
= 0;
980 flush_scheduled_work();
981 bc
->stat
= EPP_DCDBIT
;
983 pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0);
984 parport_write_control(pp
, 0); /* reset the adapter */
985 parport_release(bc
->pdev
);
986 parport_unregister_device(bc
->pdev
);
988 dev_kfree_skb(bc
->skb
);
990 printk(KERN_INFO
"%s: close epp at iobase 0x%lx irq %u\n",
991 bc_drvname
, dev
->base_addr
, dev
->irq
);
995 /* --------------------------------------------------------------------- */
997 static int baycom_setmode(struct baycom_state
*bc
, const char *modestr
)
1001 if (strstr(modestr
,"intclk"))
1003 if (strstr(modestr
,"extclk"))
1005 if (strstr(modestr
,"intmodem"))
1006 bc
->cfg
.extmodem
= 0;
1007 if (strstr(modestr
,"extmodem"))
1008 bc
->cfg
.extmodem
= 1;
1009 if (strstr(modestr
,"noloopback"))
1010 bc
->cfg
.loopback
= 0;
1011 if (strstr(modestr
,"loopback"))
1012 bc
->cfg
.loopback
= 1;
1013 if ((cp
= strstr(modestr
,"fclk="))) {
1014 bc
->cfg
.fclk
= simple_strtoul(cp
+5, NULL
, 0);
1015 if (bc
->cfg
.fclk
< 1000000)
1016 bc
->cfg
.fclk
= 1000000;
1017 if (bc
->cfg
.fclk
> 25000000)
1018 bc
->cfg
.fclk
= 25000000;
1020 if ((cp
= strstr(modestr
,"bps="))) {
1021 bc
->cfg
.bps
= simple_strtoul(cp
+4, NULL
, 0);
1022 if (bc
->cfg
.bps
< 1000)
1024 if (bc
->cfg
.bps
> 1500000)
1025 bc
->cfg
.bps
= 1500000;
1030 /* --------------------------------------------------------------------- */
1032 static int baycom_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1034 struct baycom_state
*bc
= netdev_priv(dev
);
1035 struct hdlcdrv_ioctl hi
;
1037 if (cmd
!= SIOCDEVPRIVATE
)
1038 return -ENOIOCTLCMD
;
1040 if (copy_from_user(&hi
, ifr
->ifr_data
, sizeof(hi
)))
1044 return -ENOIOCTLCMD
;
1046 case HDLCDRVCTL_GETCHANNELPAR
:
1047 hi
.data
.cp
.tx_delay
= bc
->ch_params
.tx_delay
;
1048 hi
.data
.cp
.tx_tail
= bc
->ch_params
.tx_tail
;
1049 hi
.data
.cp
.slottime
= bc
->ch_params
.slottime
;
1050 hi
.data
.cp
.ppersist
= bc
->ch_params
.ppersist
;
1051 hi
.data
.cp
.fulldup
= bc
->ch_params
.fulldup
;
1054 case HDLCDRVCTL_SETCHANNELPAR
:
1055 if (!capable(CAP_NET_ADMIN
))
1057 bc
->ch_params
.tx_delay
= hi
.data
.cp
.tx_delay
;
1058 bc
->ch_params
.tx_tail
= hi
.data
.cp
.tx_tail
;
1059 bc
->ch_params
.slottime
= hi
.data
.cp
.slottime
;
1060 bc
->ch_params
.ppersist
= hi
.data
.cp
.ppersist
;
1061 bc
->ch_params
.fulldup
= hi
.data
.cp
.fulldup
;
1062 bc
->hdlctx
.slotcnt
= 1;
1065 case HDLCDRVCTL_GETMODEMPAR
:
1066 hi
.data
.mp
.iobase
= dev
->base_addr
;
1067 hi
.data
.mp
.irq
= dev
->irq
;
1068 hi
.data
.mp
.dma
= dev
->dma
;
1069 hi
.data
.mp
.dma2
= 0;
1070 hi
.data
.mp
.seriobase
= 0;
1071 hi
.data
.mp
.pariobase
= 0;
1072 hi
.data
.mp
.midiiobase
= 0;
1075 case HDLCDRVCTL_SETMODEMPAR
:
1076 if ((!capable(CAP_SYS_RAWIO
)) || netif_running(dev
))
1078 dev
->base_addr
= hi
.data
.mp
.iobase
;
1079 dev
->irq
= /*hi.data.mp.irq*/0;
1080 dev
->dma
= /*hi.data.mp.dma*/0;
1083 case HDLCDRVCTL_GETSTAT
:
1084 hi
.data
.cs
.ptt
= !!(bc
->stat
& EPP_PTTBIT
);
1085 hi
.data
.cs
.dcd
= !(bc
->stat
& EPP_DCDBIT
);
1086 hi
.data
.cs
.ptt_keyed
= bc
->ptt_keyed
;
1087 hi
.data
.cs
.tx_packets
= bc
->stats
.tx_packets
;
1088 hi
.data
.cs
.tx_errors
= bc
->stats
.tx_errors
;
1089 hi
.data
.cs
.rx_packets
= bc
->stats
.rx_packets
;
1090 hi
.data
.cs
.rx_errors
= bc
->stats
.rx_errors
;
1093 case HDLCDRVCTL_OLDGETSTAT
:
1094 hi
.data
.ocs
.ptt
= !!(bc
->stat
& EPP_PTTBIT
);
1095 hi
.data
.ocs
.dcd
= !(bc
->stat
& EPP_DCDBIT
);
1096 hi
.data
.ocs
.ptt_keyed
= bc
->ptt_keyed
;
1099 case HDLCDRVCTL_CALIBRATE
:
1100 if (!capable(CAP_SYS_RAWIO
))
1102 bc
->hdlctx
.calibrate
= hi
.data
.calibrate
* bc
->bitrate
/ 8;
1105 case HDLCDRVCTL_DRIVERNAME
:
1106 strncpy(hi
.data
.drivername
, "baycom_epp", sizeof(hi
.data
.drivername
));
1109 case HDLCDRVCTL_GETMODE
:
1110 sprintf(hi
.data
.modename
, "%sclk,%smodem,fclk=%d,bps=%d%s",
1111 bc
->cfg
.intclk
? "int" : "ext",
1112 bc
->cfg
.extmodem
? "ext" : "int", bc
->cfg
.fclk
, bc
->cfg
.bps
,
1113 bc
->cfg
.loopback
? ",loopback" : "");
1116 case HDLCDRVCTL_SETMODE
:
1117 if (!capable(CAP_NET_ADMIN
) || netif_running(dev
))
1119 hi
.data
.modename
[sizeof(hi
.data
.modename
)-1] = '\0';
1120 return baycom_setmode(bc
, hi
.data
.modename
);
1122 case HDLCDRVCTL_MODELIST
:
1123 strncpy(hi
.data
.modename
, "intclk,extclk,intmodem,extmodem,divider=x",
1124 sizeof(hi
.data
.modename
));
1127 case HDLCDRVCTL_MODEMPARMASK
:
1128 return HDLCDRV_PARMASK_IOBASE
;
1131 if (copy_to_user(ifr
->ifr_data
, &hi
, sizeof(hi
)))
1136 /* --------------------------------------------------------------------- */
1139 * Check for a network adaptor of this type, and return '0' if one exists.
1140 * If dev->base_addr == 0, probe all likely locations.
1141 * If dev->base_addr == 1, always return failure.
1142 * If dev->base_addr == 2, allocate space for the device and return success
1143 * (detachable devices only).
1145 static void baycom_probe(struct net_device
*dev
)
1147 static char ax25_bcast
[AX25_ADDR_LEN
] = {
1148 'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1
1150 static char ax25_nocall
[AX25_ADDR_LEN
] = {
1151 'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1
1153 const struct hdlcdrv_channel_params dflt_ch_params
= {
1156 struct baycom_state
*bc
;
1159 * not a real probe! only initialize data structures
1161 bc
= netdev_priv(dev
);
1163 * initialize the baycom_state struct
1165 bc
->ch_params
= dflt_ch_params
;
1169 * initialize the device struct
1171 dev
->open
= epp_open
;
1172 dev
->stop
= epp_close
;
1173 dev
->do_ioctl
= baycom_ioctl
;
1174 dev
->hard_start_xmit
= baycom_send_packet
;
1175 dev
->get_stats
= baycom_get_stats
;
1177 /* Fill in the fields of the device structure */
1180 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1181 dev
->hard_header
= ax25_encapsulate
;
1182 dev
->rebuild_header
= ax25_rebuild_header
;
1183 #else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
1184 dev
->hard_header
= NULL
;
1185 dev
->rebuild_header
= NULL
;
1186 #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
1187 dev
->set_mac_address
= baycom_set_mac_address
;
1189 dev
->type
= ARPHRD_AX25
; /* AF_AX25 device */
1190 dev
->hard_header_len
= AX25_MAX_HEADER_LEN
+ AX25_BPQ_HEADER_LEN
;
1191 dev
->mtu
= AX25_DEF_PACLEN
; /* eth_mtu is the default */
1192 dev
->addr_len
= AX25_ADDR_LEN
; /* sizeof an ax.25 address */
1193 memcpy(dev
->broadcast
, ax25_bcast
, AX25_ADDR_LEN
);
1194 memcpy(dev
->dev_addr
, ax25_nocall
, AX25_ADDR_LEN
);
1195 dev
->tx_queue_len
= 16;
1197 /* New style flags */
1201 /* --------------------------------------------------------------------- */
1204 * command line settable parameters
1206 static const char *mode
[NR_PORTS
] = { "", };
1207 static int iobase
[NR_PORTS
] = { 0x378, };
1209 module_param_array(mode
, charp
, NULL
, 0);
1210 MODULE_PARM_DESC(mode
, "baycom operating mode");
1211 module_param_array(iobase
, int, NULL
, 0);
1212 MODULE_PARM_DESC(iobase
, "baycom io base address");
1214 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
1215 MODULE_DESCRIPTION("Baycom epp amateur radio modem driver");
1216 MODULE_LICENSE("GPL");
1218 /* --------------------------------------------------------------------- */
1220 static void __init
baycom_epp_dev_setup(struct net_device
*dev
)
1222 struct baycom_state
*bc
= netdev_priv(dev
);
1225 * initialize part of the baycom_state struct
1227 bc
->magic
= BAYCOM_MAGIC
;
1228 bc
->cfg
.fclk
= 19666600;
1231 * initialize part of the device struct
1236 static int __init
init_baycomepp(void)
1243 * register net devices
1245 for (i
= 0; i
< NR_PORTS
; i
++) {
1246 struct net_device
*dev
;
1248 dev
= alloc_netdev(sizeof(struct baycom_state
), "bce%d",
1249 baycom_epp_dev_setup
);
1252 printk(KERN_WARNING
"bce%d : out of memory\n", i
);
1253 return found
? 0 : -ENOMEM
;
1256 sprintf(dev
->name
, "bce%d", i
);
1257 dev
->base_addr
= iobase
[i
];
1264 if (register_netdev(dev
)) {
1265 printk(KERN_WARNING
"%s: cannot register net device %s\n", bc_drvname
, dev
->name
);
1269 if (set_hw
&& baycom_setmode(netdev_priv(dev
), mode
[i
]))
1271 baycom_device
[i
] = dev
;
1275 return found
? 0 : -ENXIO
;
1278 static void __exit
cleanup_baycomepp(void)
1282 for(i
= 0; i
< NR_PORTS
; i
++) {
1283 struct net_device
*dev
= baycom_device
[i
];
1286 struct baycom_state
*bc
= netdev_priv(dev
);
1287 if (bc
->magic
== BAYCOM_MAGIC
) {
1288 unregister_netdev(dev
);
1291 printk(paranoia_str
, "cleanup_module");
1296 module_init(init_baycomepp
);
1297 module_exit(cleanup_baycomepp
);
1299 /* --------------------------------------------------------------------- */
1304 * format: baycom_epp=io,mode
1305 * mode: fpga config options
1308 static int __init
baycom_epp_setup(char *str
)
1310 static unsigned __initdata nr_dev
= 0;
1313 if (nr_dev
>= NR_PORTS
)
1315 str
= get_options(str
, 2, ints
);
1319 iobase
[nr_dev
] = ints
[1];
1324 __setup("baycom_epp=", baycom_epp_setup
);
1327 /* --------------------------------------------------------------------- */