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/crc-ccitt.h>
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/init.h>
47 #include <linux/sched.h>
48 #include <linux/string.h>
49 #include <linux/workqueue.h>
51 #include <linux/parport.h>
52 #include <linux/if_arp.h>
53 #include <linux/hdlcdrv.h>
54 #include <linux/baycom.h>
55 #include <linux/jiffies.h>
56 #include <linux/random.h>
58 #include <asm/uaccess.h>
60 /* --------------------------------------------------------------------- */
63 #define BAYCOM_MAGIC 19730510
65 /* --------------------------------------------------------------------- */
67 static const char paranoia_str
[] = KERN_ERR
68 "baycom_epp: bad magic number for hdlcdrv_state struct in routine %s\n";
70 static const char bc_drvname
[] = "baycom_epp";
71 static const char bc_drvinfo
[] = KERN_INFO
"baycom_epp: (C) 1998-2000 Thomas Sailer, HB9JNX/AE4WA\n"
72 "baycom_epp: version 0.7 compiled " __TIME__
" " __DATE__
"\n";
74 /* --------------------------------------------------------------------- */
78 static struct net_device
*baycom_device
[NR_PORTS
];
80 /* --------------------------------------------------------------------- */
82 /* EPP status register */
83 #define EPP_DCDBIT 0x80
84 #define EPP_PTTBIT 0x08
86 #define EPP_NRAEF 0x02
89 #define EPP_NTAEF 0x10
90 #define EPP_NTEF EPP_PTTBIT
92 /* EPP control register */
93 #define EPP_TX_FIFO_ENABLE 0x10
94 #define EPP_RX_FIFO_ENABLE 0x08
95 #define EPP_MODEM_ENABLE 0x20
97 #define EPP_IRQ_ENABLE 0x10
100 #define LPTREG_ECONTROL 0x402
101 #define LPTREG_CONFIGB 0x401
102 #define LPTREG_CONFIGA 0x400
103 #define LPTREG_EPPDATA 0x004
104 #define LPTREG_EPPADDR 0x003
105 #define LPTREG_CONTROL 0x002
106 #define LPTREG_STATUS 0x001
107 #define LPTREG_DATA 0x000
109 /* LPT control register */
110 #define LPTCTRL_PROGRAM 0x04 /* 0 to reprogram */
111 #define LPTCTRL_WRITE 0x01
112 #define LPTCTRL_ADDRSTB 0x08
113 #define LPTCTRL_DATASTB 0x02
114 #define LPTCTRL_INTEN 0x10
116 /* LPT status register */
117 #define LPTSTAT_SHIFT_NINTR 6
118 #define LPTSTAT_WAIT 0x80
119 #define LPTSTAT_NINTR (1<<LPTSTAT_SHIFT_NINTR)
120 #define LPTSTAT_PE 0x20
121 #define LPTSTAT_DONE 0x10
122 #define LPTSTAT_NERROR 0x08
123 #define LPTSTAT_EPPTIMEOUT 0x01
125 /* LPT data register */
126 #define LPTDATA_SHIFT_TDI 0
127 #define LPTDATA_SHIFT_TMS 2
128 #define LPTDATA_TDI (1<<LPTDATA_SHIFT_TDI)
129 #define LPTDATA_TCK 0x02
130 #define LPTDATA_TMS (1<<LPTDATA_SHIFT_TMS)
131 #define LPTDATA_INITBIAS 0x80
134 /* EPP modem config/status bits */
135 #define EPP_DCDBIT 0x80
136 #define EPP_PTTBIT 0x08
137 #define EPP_RXEBIT 0x01
138 #define EPP_RXAEBIT 0x02
139 #define EPP_RXHFULL 0x04
141 #define EPP_NTHF 0x20
142 #define EPP_NTAEF 0x10
143 #define EPP_NTEF EPP_PTTBIT
145 #define EPP_TX_FIFO_ENABLE 0x10
146 #define EPP_RX_FIFO_ENABLE 0x08
147 #define EPP_MODEM_ENABLE 0x20
148 #define EPP_LEDS 0xC0
149 #define EPP_IRQ_ENABLE 0x10
151 /* Xilinx 4k JTAG instructions */
152 #define XC4K_IRLENGTH 3
153 #define XC4K_EXTEST 0
154 #define XC4K_PRELOAD 1
155 #define XC4K_CONFIGURE 5
156 #define XC4K_BYPASS 7
158 #define EPP_CONVENTIONAL 0
160 #define EPP_FPGAEXTSTATUS 2
162 #define TXBUFFER_SIZE ((HDLCDRV_MAXFLEN*6/5)+8)
164 /* ---------------------------------------------------------------------- */
166 * Information that need to be kept for each board.
169 struct baycom_state
{
172 struct pardevice
*pdev
;
173 struct net_device
*dev
;
174 unsigned int work_running
;
175 struct delayed_work run_work
;
177 unsigned int bitrate
;
184 unsigned int extmodem
;
185 unsigned int loopback
;
188 struct hdlcdrv_channel_params ch_params
;
191 unsigned int bitbuf
, bitstream
, numbits
, state
;
192 unsigned char *bufptr
;
194 unsigned char buf
[TXBUFFER_SIZE
];
201 enum { tx_idle
= 0, tx_keyup
, tx_data
, tx_tail
} state
;
202 unsigned char *bufptr
;
204 unsigned char buf
[TXBUFFER_SIZE
];
207 unsigned int ptt_keyed
;
208 struct sk_buff
*skb
; /* next transmit packet */
212 unsigned long last_jiffies
;
214 unsigned last_intcnt
;
217 unsigned int mod_cycles
;
218 unsigned int demod_cycles
;
220 #endif /* BAYCOM_DEBUG */
223 /* --------------------------------------------------------------------- */
227 /* --------------------------------------------------------------------- */
229 #define PARAM_TXDELAY 1
230 #define PARAM_PERSIST 2
231 #define PARAM_SLOTTIME 3
232 #define PARAM_TXTAIL 4
233 #define PARAM_FULLDUP 5
234 #define PARAM_HARDWARE 6
235 #define PARAM_RETURN 255
237 /* --------------------------------------------------------------------- */
239 * the CRC routines are stolen from WAMPES
244 /*---------------------------------------------------------------------------*/
247 /*---------------------------------------------------------------------------*/
249 static inline int check_crc_ccitt(const unsigned char *buf
, int cnt
)
251 return (crc_ccitt(0xffff, buf
, cnt
) & 0xffff) == 0xf0b8;
254 /*---------------------------------------------------------------------------*/
256 static inline int calc_crc_ccitt(const unsigned char *buf
, int cnt
)
258 return (crc_ccitt(0xffff, buf
, cnt
) ^ 0xffff) & 0xffff;
261 /* ---------------------------------------------------------------------- */
263 #define tenms_to_flags(bc,tenms) ((tenms * bc->bitrate) / 800)
265 /* --------------------------------------------------------------------- */
267 static inline void baycom_int_freq(struct baycom_state
*bc
)
270 unsigned long cur_jiffies
= jiffies
;
272 * measure the interrupt frequency
274 bc
->debug_vals
.cur_intcnt
++;
275 if (time_after_eq(cur_jiffies
, bc
->debug_vals
.last_jiffies
+ HZ
)) {
276 bc
->debug_vals
.last_jiffies
= cur_jiffies
;
277 bc
->debug_vals
.last_intcnt
= bc
->debug_vals
.cur_intcnt
;
278 bc
->debug_vals
.cur_intcnt
= 0;
279 bc
->debug_vals
.last_pllcorr
= bc
->debug_vals
.cur_pllcorr
;
280 bc
->debug_vals
.cur_pllcorr
= 0;
282 #endif /* BAYCOM_DEBUG */
285 /* ---------------------------------------------------------------------- */
287 * eppconfig_path should be setable via /proc/sys.
290 static char eppconfig_path
[256] = "/usr/sbin/eppfpga";
292 static char *envp
[] = { "HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL
};
294 /* eppconfig: called during ifconfig up to configure the modem */
295 static int eppconfig(struct baycom_state
*bc
)
299 char *argv
[] = { eppconfig_path
, "-s", "-p", portarg
, "-m", modearg
,
302 /* set up arguments */
303 sprintf(modearg
, "%sclk,%smodem,fclk=%d,bps=%d,divider=%d%s,extstat",
304 bc
->cfg
.intclk
? "int" : "ext",
305 bc
->cfg
.extmodem
? "ext" : "int", bc
->cfg
.fclk
, bc
->cfg
.bps
,
306 (bc
->cfg
.fclk
+ 8 * bc
->cfg
.bps
) / (16 * bc
->cfg
.bps
),
307 bc
->cfg
.loopback
? ",loopback" : "");
308 sprintf(portarg
, "%ld", bc
->pdev
->port
->base
);
309 printk(KERN_DEBUG
"%s: %s -s -p %s -m %s\n", bc_drvname
, eppconfig_path
, portarg
, modearg
);
311 return call_usermodehelper(eppconfig_path
, argv
, envp
, UMH_WAIT_PROC
);
314 /* ---------------------------------------------------------------------- */
316 static inline void do_kiss_params(struct baycom_state
*bc
,
317 unsigned char *data
, unsigned long len
)
321 #define PKP(a,b) printk(KERN_INFO "baycomm_epp: channel params: " a "\n", b)
322 #else /* KISS_VERBOSE */
324 #endif /* KISS_VERBOSE */
330 bc
->ch_params
.tx_delay
= data
[1];
331 PKP("TX delay = %ums", 10 * bc
->ch_params
.tx_delay
);
334 bc
->ch_params
.ppersist
= data
[1];
335 PKP("p persistence = %u", bc
->ch_params
.ppersist
);
338 bc
->ch_params
.slottime
= data
[1];
339 PKP("slot time = %ums", bc
->ch_params
.slottime
);
342 bc
->ch_params
.tx_tail
= data
[1];
343 PKP("TX tail = %ums", bc
->ch_params
.tx_tail
);
346 bc
->ch_params
.fulldup
= !!data
[1];
347 PKP("%s duplex", bc
->ch_params
.fulldup
? "full" : "half");
355 /* --------------------------------------------------------------------- */
357 static void encode_hdlc(struct baycom_state
*bc
)
360 unsigned char *wp
, *bp
;
362 unsigned bitstream
, notbitstream
, bitbuf
, numbit
, crc
;
363 unsigned char crcarr
[2];
366 if (bc
->hdlctx
.bufcnt
> 0)
372 pkt_len
= skb
->len
-1; /* strip KISS byte */
375 crc
= calc_crc_ccitt(bp
, pkt_len
);
377 crcarr
[1] = crc
>> 8;
379 bitstream
= bitbuf
= numbit
= 0;
380 while (pkt_len
> -2) {
382 bitstream
|= ((unsigned int)*bp
) << 8;
383 bitbuf
|= ((unsigned int)*bp
) << numbit
;
384 notbitstream
= ~bitstream
;
389 for (j
= 0; j
< 8; j
++)
390 if (unlikely(!(notbitstream
& (0x1f0 << j
)))) {
391 bitstream
&= ~(0x100 << j
);
392 bitbuf
= (bitbuf
& (((2 << j
) << numbit
) - 1)) |
393 ((bitbuf
& ~(((2 << j
) << numbit
) - 1)) << 1);
395 notbitstream
= ~bitstream
;
398 while (numbit
>= 8) {
404 bitbuf
|= 0x7e7e << numbit
;
406 while (numbit
>= 8) {
411 bc
->hdlctx
.bufptr
= bc
->hdlctx
.buf
;
412 bc
->hdlctx
.bufcnt
= wp
- bc
->hdlctx
.buf
;
414 bc
->dev
->stats
.tx_packets
++;
417 /* ---------------------------------------------------------------------- */
419 static int transmit(struct baycom_state
*bc
, int cnt
, unsigned char stat
)
421 struct parport
*pp
= bc
->pdev
->port
;
422 unsigned char tmp
[128];
425 if (bc
->hdlctx
.state
== tx_tail
&& !(stat
& EPP_PTTBIT
))
426 bc
->hdlctx
.state
= tx_idle
;
427 if (bc
->hdlctx
.state
== tx_idle
&& bc
->hdlctx
.calibrate
<= 0) {
428 if (bc
->hdlctx
.bufcnt
<= 0)
430 if (bc
->hdlctx
.bufcnt
<= 0)
432 if (!bc
->ch_params
.fulldup
) {
433 if (!(stat
& EPP_DCDBIT
)) {
434 bc
->hdlctx
.slotcnt
= bc
->ch_params
.slottime
;
437 if ((--bc
->hdlctx
.slotcnt
) > 0)
439 bc
->hdlctx
.slotcnt
= bc
->ch_params
.slottime
;
440 if ((random32() % 256) > bc
->ch_params
.ppersist
)
444 if (bc
->hdlctx
.state
== tx_idle
&& bc
->hdlctx
.bufcnt
> 0) {
445 bc
->hdlctx
.state
= tx_keyup
;
446 bc
->hdlctx
.flags
= tenms_to_flags(bc
, bc
->ch_params
.tx_delay
);
450 switch (bc
->hdlctx
.state
) {
452 i
= min_t(int, cnt
, bc
->hdlctx
.flags
);
454 bc
->hdlctx
.flags
-= i
;
455 if (bc
->hdlctx
.flags
<= 0)
456 bc
->hdlctx
.state
= tx_data
;
457 memset(tmp
, 0x7e, sizeof(tmp
));
459 j
= (i
> sizeof(tmp
)) ? sizeof(tmp
) : i
;
460 if (j
!= pp
->ops
->epp_write_data(pp
, tmp
, j
, 0))
467 if (bc
->hdlctx
.bufcnt
<= 0) {
469 if (bc
->hdlctx
.bufcnt
<= 0) {
470 bc
->hdlctx
.state
= tx_tail
;
471 bc
->hdlctx
.flags
= tenms_to_flags(bc
, bc
->ch_params
.tx_tail
);
475 i
= min_t(int, cnt
, bc
->hdlctx
.bufcnt
);
476 bc
->hdlctx
.bufcnt
-= i
;
478 if (i
!= pp
->ops
->epp_write_data(pp
, bc
->hdlctx
.bufptr
, i
, 0))
480 bc
->hdlctx
.bufptr
+= i
;
485 if (bc
->hdlctx
.bufcnt
> 0) {
486 bc
->hdlctx
.state
= tx_data
;
489 i
= min_t(int, cnt
, bc
->hdlctx
.flags
);
492 bc
->hdlctx
.flags
-= i
;
493 memset(tmp
, 0x7e, sizeof(tmp
));
495 j
= (i
> sizeof(tmp
)) ? sizeof(tmp
) : i
;
496 if (j
!= pp
->ops
->epp_write_data(pp
, tmp
, j
, 0))
503 default: /* fall through */
504 if (bc
->hdlctx
.calibrate
<= 0)
506 i
= min_t(int, cnt
, bc
->hdlctx
.calibrate
);
508 bc
->hdlctx
.calibrate
-= i
;
509 memset(tmp
, 0, sizeof(tmp
));
511 j
= (i
> sizeof(tmp
)) ? sizeof(tmp
) : i
;
512 if (j
!= pp
->ops
->epp_write_data(pp
, tmp
, j
, 0))
522 /* ---------------------------------------------------------------------- */
524 static void do_rxpacket(struct net_device
*dev
)
526 struct baycom_state
*bc
= netdev_priv(dev
);
531 if (bc
->hdlcrx
.bufcnt
< 4)
533 if (!check_crc_ccitt(bc
->hdlcrx
.buf
, bc
->hdlcrx
.bufcnt
))
535 pktlen
= bc
->hdlcrx
.bufcnt
-2+1; /* KISS kludge */
536 if (!(skb
= dev_alloc_skb(pktlen
))) {
537 printk("%s: memory squeeze, dropping packet\n", dev
->name
);
538 dev
->stats
.rx_dropped
++;
541 cp
= skb_put(skb
, pktlen
);
542 *cp
++ = 0; /* KISS kludge */
543 memcpy(cp
, bc
->hdlcrx
.buf
, pktlen
- 1);
544 skb
->protocol
= ax25_type_trans(skb
, dev
);
546 dev
->stats
.rx_packets
++;
549 static int receive(struct net_device
*dev
, int cnt
)
551 struct baycom_state
*bc
= netdev_priv(dev
);
552 struct parport
*pp
= bc
->pdev
->port
;
553 unsigned int bitbuf
, notbitstream
, bitstream
, numbits
, state
;
554 unsigned char tmp
[128];
559 numbits
= bc
->hdlcrx
.numbits
;
560 state
= bc
->hdlcrx
.state
;
561 bitstream
= bc
->hdlcrx
.bitstream
;
562 bitbuf
= bc
->hdlcrx
.bitbuf
;
564 cnt2
= (cnt
> sizeof(tmp
)) ? sizeof(tmp
) : cnt
;
566 if (cnt2
!= pp
->ops
->epp_read_data(pp
, tmp
, cnt2
, 0)) {
571 for (; cnt2
> 0; cnt2
--, cp
++) {
573 bitstream
|= (*cp
) << 8;
575 bitbuf
|= (*cp
) << 8;
577 notbitstream
= ~bitstream
;
578 for (j
= 0; j
< 8; j
++) {
581 if (unlikely(!(notbitstream
& (0x0fc << j
)))) {
584 if (!(notbitstream
& (0x1fc << j
)))
588 else if ((bitstream
& (0x1fe << j
)) == (0x0fc << j
)) {
591 bc
->hdlcrx
.bufcnt
= 0;
592 bc
->hdlcrx
.bufptr
= bc
->hdlcrx
.buf
;
599 else if (unlikely((bitstream
& (0x1f8 << j
)) == (0xf8 << j
))) {
601 bitbuf
= (bitbuf
& ((~0xff) << j
)) | ((bitbuf
& ~((~0xff) << j
)) << 1);
604 while (state
&& numbits
>= 8) {
605 if (bc
->hdlcrx
.bufcnt
>= TXBUFFER_SIZE
) {
608 *(bc
->hdlcrx
.bufptr
)++ = bitbuf
>> (16-numbits
);
615 bc
->hdlcrx
.numbits
= numbits
;
616 bc
->hdlcrx
.state
= state
;
617 bc
->hdlcrx
.bitstream
= bitstream
;
618 bc
->hdlcrx
.bitbuf
= bitbuf
;
622 /* --------------------------------------------------------------------- */
633 #endif /* __i386__ */
635 static void epp_bh(struct work_struct
*work
)
637 struct net_device
*dev
;
638 struct baycom_state
*bc
;
641 unsigned char tmp
[2];
642 unsigned int time1
= 0, time2
= 0, time3
= 0;
645 bc
= container_of(work
, struct baycom_state
, run_work
.work
);
647 if (!bc
->work_running
)
652 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
655 bc
->debug_vals
.last_pllcorr
= stat
;
657 if (bc
->modem
== EPP_FPGAEXTSTATUS
) {
658 /* get input count */
659 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
|1;
660 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
662 if (pp
->ops
->epp_read_addr(pp
, tmp
, 2, 0) != 2)
664 cnt
= tmp
[0] | (tmp
[1] << 8);
666 /* get output count */
667 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
|2;
668 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
670 if (pp
->ops
->epp_read_addr(pp
, tmp
, 2, 0) != 2)
672 cnt2
= tmp
[0] | (tmp
[1] << 8);
673 cnt2
= 16384 - (cnt2
& 0x7fff);
674 /* return to normal */
675 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
;
676 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
678 if (transmit(bc
, cnt2
, stat
))
681 if (receive(dev
, cnt
))
683 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
688 switch (stat
& (EPP_NTAEF
|EPP_NTHF
)) {
705 if (transmit(bc
, cnt
, stat
))
709 while ((stat
& (EPP_NRAEF
|EPP_NRHF
)) != EPP_NRHF
) {
710 switch (stat
& (EPP_NRAEF
|EPP_NRHF
)) {
723 if (receive(dev
, cnt
))
725 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
729 if (bc
->bitrate
< 50000)
731 else if (bc
->bitrate
< 100000)
733 while (cnt
> 0 && stat
& EPP_NREF
) {
737 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
743 bc
->debug_vals
.mod_cycles
= time2
- time1
;
744 bc
->debug_vals
.demod_cycles
= time3
- time2
;
745 #endif /* BAYCOM_DEBUG */
746 schedule_delayed_work(&bc
->run_work
, 1);
748 netif_wake_queue(dev
);
751 printk(KERN_ERR
"%s: EPP timeout!\n", bc_drvname
);
754 /* ---------------------------------------------------------------------- */
756 * ===================== network driver interface =========================
759 static int baycom_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
761 struct baycom_state
*bc
= netdev_priv(dev
);
763 if (skb
->data
[0] != 0) {
764 do_kiss_params(bc
, skb
->data
, skb
->len
);
769 return NETDEV_TX_LOCKED
;
770 /* strip KISS byte */
771 if (skb
->len
>= HDLCDRV_MAXFLEN
+1 || skb
->len
< 3) {
775 netif_stop_queue(dev
);
780 /* --------------------------------------------------------------------- */
782 static int baycom_set_mac_address(struct net_device
*dev
, void *addr
)
784 struct sockaddr
*sa
= (struct sockaddr
*)addr
;
786 /* addr is an AX.25 shifted ASCII mac address */
787 memcpy(dev
->dev_addr
, sa
->sa_data
, dev
->addr_len
);
791 /* --------------------------------------------------------------------- */
793 static void epp_wakeup(void *handle
)
795 struct net_device
*dev
= (struct net_device
*)handle
;
796 struct baycom_state
*bc
= netdev_priv(dev
);
798 printk(KERN_DEBUG
"baycom_epp: %s: why am I being woken up?\n", dev
->name
);
799 if (!parport_claim(bc
->pdev
))
800 printk(KERN_DEBUG
"baycom_epp: %s: I'm broken.\n", dev
->name
);
803 /* --------------------------------------------------------------------- */
806 * Open/initialize the board. This is called (in the current kernel)
807 * sometime after booting when the 'ifconfig' program is run.
809 * This routine should set everything up anew at each open, even
810 * registers that "should" only need to be set once at boot, so that
811 * there is non-reboot way to recover if something goes wrong.
814 static int epp_open(struct net_device
*dev
)
816 struct baycom_state
*bc
= netdev_priv(dev
);
817 struct parport
*pp
= parport_find_base(dev
->base_addr
);
819 unsigned char tmp
[128];
821 unsigned long tstart
;
824 printk(KERN_ERR
"%s: parport at 0x%lx unknown\n", bc_drvname
, dev
->base_addr
);
827 if ((~pp
->modes
) & (PARPORT_MODE_TRISTATE
| PARPORT_MODE_PCSPP
| PARPORT_MODE_SAFEININT
)) {
828 printk(KERN_ERR
"%s: parport at 0x%lx cannot be used\n",
829 bc_drvname
, pp
->base
);
830 parport_put_port(pp
);
833 memset(&bc
->modem
, 0, sizeof(bc
->modem
));
834 bc
->pdev
= parport_register_device(pp
, dev
->name
, NULL
, epp_wakeup
,
835 NULL
, PARPORT_DEV_EXCL
, dev
);
836 parport_put_port(pp
);
838 printk(KERN_ERR
"%s: cannot register parport at 0x%lx\n", bc_drvname
, pp
->base
);
841 if (parport_claim(bc
->pdev
)) {
842 printk(KERN_ERR
"%s: parport at 0x%lx busy\n", bc_drvname
, pp
->base
);
843 parport_unregister_device(bc
->pdev
);
846 dev
->irq
= /*pp->irq*/ 0;
847 INIT_DELAYED_WORK(&bc
->run_work
, epp_bh
);
848 bc
->work_running
= 1;
849 bc
->modem
= EPP_CONVENTIONAL
;
851 printk(KERN_INFO
"%s: no FPGA detected, assuming conventional EPP modem\n", bc_drvname
);
853 bc
->modem
= /*EPP_FPGA*/ EPP_FPGAEXTSTATUS
;
854 parport_write_control(pp
, LPTCTRL_PROGRAM
); /* prepare EPP mode; we aren't using interrupts */
855 /* reset the modem */
857 tmp
[1] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
;
858 if (pp
->ops
->epp_write_addr(pp
, tmp
, 2, 0) != 2)
860 /* autoprobe baud rate */
863 while (time_before(jiffies
, tstart
+ HZ
/3)) {
864 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
866 if ((stat
& (EPP_NRAEF
|EPP_NRHF
)) == EPP_NRHF
) {
870 if (pp
->ops
->epp_read_data(pp
, tmp
, 128, 0) != 128)
872 if (pp
->ops
->epp_read_data(pp
, tmp
, 128, 0) != 128)
876 for (j
= 0; j
< 256; j
++) {
877 if (pp
->ops
->epp_read_addr(pp
, &stat
, 1, 0) != 1)
879 if (!(stat
& EPP_NREF
))
881 if (pp
->ops
->epp_read_data(pp
, tmp
, 1, 0) != 1)
885 tstart
= jiffies
- tstart
;
886 bc
->bitrate
= i
* (8 * HZ
) / tstart
;
888 i
= bc
->bitrate
>> 3;
889 while (j
< 7 && i
> 150) {
893 printk(KERN_INFO
"%s: autoprobed bitrate: %d int divider: %d int rate: %d\n",
894 bc_drvname
, bc
->bitrate
, j
, bc
->bitrate
>> (j
+2));
895 tmp
[0] = EPP_TX_FIFO_ENABLE
|EPP_RX_FIFO_ENABLE
|EPP_MODEM_ENABLE
/*|j*/;
896 if (pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0) != 1)
899 * initialise hdlc variables
901 bc
->hdlcrx
.state
= 0;
902 bc
->hdlcrx
.numbits
= 0;
903 bc
->hdlctx
.state
= tx_idle
;
904 bc
->hdlctx
.bufcnt
= 0;
905 bc
->hdlctx
.slotcnt
= bc
->ch_params
.slottime
;
906 bc
->hdlctx
.calibrate
= 0;
907 /* start the bottom half stuff */
908 schedule_delayed_work(&bc
->run_work
, 1);
909 netif_start_queue(dev
);
913 printk(KERN_ERR
"%s: epp timeout during bitrate probe\n", bc_drvname
);
914 parport_write_control(pp
, 0); /* reset the adapter */
915 parport_release(bc
->pdev
);
916 parport_unregister_device(bc
->pdev
);
920 /* --------------------------------------------------------------------- */
922 static int epp_close(struct net_device
*dev
)
924 struct baycom_state
*bc
= netdev_priv(dev
);
925 struct parport
*pp
= bc
->pdev
->port
;
926 unsigned char tmp
[1];
928 bc
->work_running
= 0;
929 cancel_delayed_work_sync(&bc
->run_work
);
930 bc
->stat
= EPP_DCDBIT
;
932 pp
->ops
->epp_write_addr(pp
, tmp
, 1, 0);
933 parport_write_control(pp
, 0); /* reset the adapter */
934 parport_release(bc
->pdev
);
935 parport_unregister_device(bc
->pdev
);
937 dev_kfree_skb(bc
->skb
);
939 printk(KERN_INFO
"%s: close epp at iobase 0x%lx irq %u\n",
940 bc_drvname
, dev
->base_addr
, dev
->irq
);
944 /* --------------------------------------------------------------------- */
946 static int baycom_setmode(struct baycom_state
*bc
, const char *modestr
)
950 if (strstr(modestr
,"intclk"))
952 if (strstr(modestr
,"extclk"))
954 if (strstr(modestr
,"intmodem"))
955 bc
->cfg
.extmodem
= 0;
956 if (strstr(modestr
,"extmodem"))
957 bc
->cfg
.extmodem
= 1;
958 if (strstr(modestr
,"noloopback"))
959 bc
->cfg
.loopback
= 0;
960 if (strstr(modestr
,"loopback"))
961 bc
->cfg
.loopback
= 1;
962 if ((cp
= strstr(modestr
,"fclk="))) {
963 bc
->cfg
.fclk
= simple_strtoul(cp
+5, NULL
, 0);
964 if (bc
->cfg
.fclk
< 1000000)
965 bc
->cfg
.fclk
= 1000000;
966 if (bc
->cfg
.fclk
> 25000000)
967 bc
->cfg
.fclk
= 25000000;
969 if ((cp
= strstr(modestr
,"bps="))) {
970 bc
->cfg
.bps
= simple_strtoul(cp
+4, NULL
, 0);
971 if (bc
->cfg
.bps
< 1000)
973 if (bc
->cfg
.bps
> 1500000)
974 bc
->cfg
.bps
= 1500000;
979 /* --------------------------------------------------------------------- */
981 static int baycom_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
983 struct baycom_state
*bc
= netdev_priv(dev
);
984 struct hdlcdrv_ioctl hi
;
986 if (cmd
!= SIOCDEVPRIVATE
)
989 if (copy_from_user(&hi
, ifr
->ifr_data
, sizeof(hi
)))
995 case HDLCDRVCTL_GETCHANNELPAR
:
996 hi
.data
.cp
.tx_delay
= bc
->ch_params
.tx_delay
;
997 hi
.data
.cp
.tx_tail
= bc
->ch_params
.tx_tail
;
998 hi
.data
.cp
.slottime
= bc
->ch_params
.slottime
;
999 hi
.data
.cp
.ppersist
= bc
->ch_params
.ppersist
;
1000 hi
.data
.cp
.fulldup
= bc
->ch_params
.fulldup
;
1003 case HDLCDRVCTL_SETCHANNELPAR
:
1004 if (!capable(CAP_NET_ADMIN
))
1006 bc
->ch_params
.tx_delay
= hi
.data
.cp
.tx_delay
;
1007 bc
->ch_params
.tx_tail
= hi
.data
.cp
.tx_tail
;
1008 bc
->ch_params
.slottime
= hi
.data
.cp
.slottime
;
1009 bc
->ch_params
.ppersist
= hi
.data
.cp
.ppersist
;
1010 bc
->ch_params
.fulldup
= hi
.data
.cp
.fulldup
;
1011 bc
->hdlctx
.slotcnt
= 1;
1014 case HDLCDRVCTL_GETMODEMPAR
:
1015 hi
.data
.mp
.iobase
= dev
->base_addr
;
1016 hi
.data
.mp
.irq
= dev
->irq
;
1017 hi
.data
.mp
.dma
= dev
->dma
;
1018 hi
.data
.mp
.dma2
= 0;
1019 hi
.data
.mp
.seriobase
= 0;
1020 hi
.data
.mp
.pariobase
= 0;
1021 hi
.data
.mp
.midiiobase
= 0;
1024 case HDLCDRVCTL_SETMODEMPAR
:
1025 if ((!capable(CAP_SYS_RAWIO
)) || netif_running(dev
))
1027 dev
->base_addr
= hi
.data
.mp
.iobase
;
1028 dev
->irq
= /*hi.data.mp.irq*/0;
1029 dev
->dma
= /*hi.data.mp.dma*/0;
1032 case HDLCDRVCTL_GETSTAT
:
1033 hi
.data
.cs
.ptt
= !!(bc
->stat
& EPP_PTTBIT
);
1034 hi
.data
.cs
.dcd
= !(bc
->stat
& EPP_DCDBIT
);
1035 hi
.data
.cs
.ptt_keyed
= bc
->ptt_keyed
;
1036 hi
.data
.cs
.tx_packets
= dev
->stats
.tx_packets
;
1037 hi
.data
.cs
.tx_errors
= dev
->stats
.tx_errors
;
1038 hi
.data
.cs
.rx_packets
= dev
->stats
.rx_packets
;
1039 hi
.data
.cs
.rx_errors
= dev
->stats
.rx_errors
;
1042 case HDLCDRVCTL_OLDGETSTAT
:
1043 hi
.data
.ocs
.ptt
= !!(bc
->stat
& EPP_PTTBIT
);
1044 hi
.data
.ocs
.dcd
= !(bc
->stat
& EPP_DCDBIT
);
1045 hi
.data
.ocs
.ptt_keyed
= bc
->ptt_keyed
;
1048 case HDLCDRVCTL_CALIBRATE
:
1049 if (!capable(CAP_SYS_RAWIO
))
1051 bc
->hdlctx
.calibrate
= hi
.data
.calibrate
* bc
->bitrate
/ 8;
1054 case HDLCDRVCTL_DRIVERNAME
:
1055 strncpy(hi
.data
.drivername
, "baycom_epp", sizeof(hi
.data
.drivername
));
1058 case HDLCDRVCTL_GETMODE
:
1059 sprintf(hi
.data
.modename
, "%sclk,%smodem,fclk=%d,bps=%d%s",
1060 bc
->cfg
.intclk
? "int" : "ext",
1061 bc
->cfg
.extmodem
? "ext" : "int", bc
->cfg
.fclk
, bc
->cfg
.bps
,
1062 bc
->cfg
.loopback
? ",loopback" : "");
1065 case HDLCDRVCTL_SETMODE
:
1066 if (!capable(CAP_NET_ADMIN
) || netif_running(dev
))
1068 hi
.data
.modename
[sizeof(hi
.data
.modename
)-1] = '\0';
1069 return baycom_setmode(bc
, hi
.data
.modename
);
1071 case HDLCDRVCTL_MODELIST
:
1072 strncpy(hi
.data
.modename
, "intclk,extclk,intmodem,extmodem,divider=x",
1073 sizeof(hi
.data
.modename
));
1076 case HDLCDRVCTL_MODEMPARMASK
:
1077 return HDLCDRV_PARMASK_IOBASE
;
1080 if (copy_to_user(ifr
->ifr_data
, &hi
, sizeof(hi
)))
1085 /* --------------------------------------------------------------------- */
1087 static const struct net_device_ops baycom_netdev_ops
= {
1088 .ndo_open
= epp_open
,
1089 .ndo_stop
= epp_close
,
1090 .ndo_do_ioctl
= baycom_ioctl
,
1091 .ndo_start_xmit
= baycom_send_packet
,
1092 .ndo_set_mac_address
= baycom_set_mac_address
,
1096 * Check for a network adaptor of this type, and return '0' if one exists.
1097 * If dev->base_addr == 0, probe all likely locations.
1098 * If dev->base_addr == 1, always return failure.
1099 * If dev->base_addr == 2, allocate space for the device and return success
1100 * (detachable devices only).
1102 static void baycom_probe(struct net_device
*dev
)
1104 const struct hdlcdrv_channel_params dflt_ch_params
= {
1107 struct baycom_state
*bc
;
1110 * not a real probe! only initialize data structures
1112 bc
= netdev_priv(dev
);
1114 * initialize the baycom_state struct
1116 bc
->ch_params
= dflt_ch_params
;
1120 * initialize the device struct
1123 /* Fill in the fields of the device structure */
1126 dev
->netdev_ops
= &baycom_netdev_ops
;
1127 dev
->header_ops
= &ax25_header_ops
;
1129 dev
->type
= ARPHRD_AX25
; /* AF_AX25 device */
1130 dev
->hard_header_len
= AX25_MAX_HEADER_LEN
+ AX25_BPQ_HEADER_LEN
;
1131 dev
->mtu
= AX25_DEF_PACLEN
; /* eth_mtu is the default */
1132 dev
->addr_len
= AX25_ADDR_LEN
; /* sizeof an ax.25 address */
1133 memcpy(dev
->broadcast
, &ax25_bcast
, AX25_ADDR_LEN
);
1134 memcpy(dev
->dev_addr
, &null_ax25_address
, AX25_ADDR_LEN
);
1135 dev
->tx_queue_len
= 16;
1137 /* New style flags */
1141 /* --------------------------------------------------------------------- */
1144 * command line settable parameters
1146 static const char *mode
[NR_PORTS
] = { "", };
1147 static int iobase
[NR_PORTS
] = { 0x378, };
1149 module_param_array(mode
, charp
, NULL
, 0);
1150 MODULE_PARM_DESC(mode
, "baycom operating mode");
1151 module_param_array(iobase
, int, NULL
, 0);
1152 MODULE_PARM_DESC(iobase
, "baycom io base address");
1154 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
1155 MODULE_DESCRIPTION("Baycom epp amateur radio modem driver");
1156 MODULE_LICENSE("GPL");
1158 /* --------------------------------------------------------------------- */
1160 static void __init
baycom_epp_dev_setup(struct net_device
*dev
)
1162 struct baycom_state
*bc
= netdev_priv(dev
);
1165 * initialize part of the baycom_state struct
1168 bc
->magic
= BAYCOM_MAGIC
;
1169 bc
->cfg
.fclk
= 19666600;
1172 * initialize part of the device struct
1177 static int __init
init_baycomepp(void)
1184 * register net devices
1186 for (i
= 0; i
< NR_PORTS
; i
++) {
1187 struct net_device
*dev
;
1189 dev
= alloc_netdev(sizeof(struct baycom_state
), "bce%d",
1190 baycom_epp_dev_setup
);
1193 printk(KERN_WARNING
"bce%d : out of memory\n", i
);
1194 return found
? 0 : -ENOMEM
;
1197 sprintf(dev
->name
, "bce%d", i
);
1198 dev
->base_addr
= iobase
[i
];
1205 if (register_netdev(dev
)) {
1206 printk(KERN_WARNING
"%s: cannot register net device %s\n", bc_drvname
, dev
->name
);
1210 if (set_hw
&& baycom_setmode(netdev_priv(dev
), mode
[i
]))
1212 baycom_device
[i
] = dev
;
1216 return found
? 0 : -ENXIO
;
1219 static void __exit
cleanup_baycomepp(void)
1223 for(i
= 0; i
< NR_PORTS
; i
++) {
1224 struct net_device
*dev
= baycom_device
[i
];
1227 struct baycom_state
*bc
= netdev_priv(dev
);
1228 if (bc
->magic
== BAYCOM_MAGIC
) {
1229 unregister_netdev(dev
);
1232 printk(paranoia_str
, "cleanup_module");
1237 module_init(init_baycomepp
);
1238 module_exit(cleanup_baycomepp
);
1240 /* --------------------------------------------------------------------- */
1245 * format: baycom_epp=io,mode
1246 * mode: fpga config options
1249 static int __init
baycom_epp_setup(char *str
)
1251 static unsigned __initdata nr_dev
= 0;
1254 if (nr_dev
>= NR_PORTS
)
1256 str
= get_options(str
, 2, ints
);
1260 iobase
[nr_dev
] = ints
[1];
1265 __setup("baycom_epp=", baycom_epp_setup
);
1268 /* --------------------------------------------------------------------- */