1 /*****************************************************************************/
4 * yam.c -- YAM radio modem driver.
6 * Copyright (C) 1998 Frederic Rible F1OAT (frible@teaser.fr)
7 * Adapted from baycom.c driver written by 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.0 F1OAT 06.06.98 Begin of work with baycom.c source code V 0.3
30 * 0.1 F1OAT 07.06.98 Add timer polling routine for channel arbitration
31 * 0.2 F6FBB 08.06.98 Added delay after FPGA programming
32 * 0.3 F6FBB 29.07.98 Delayed PTT implementation for dupmode=2
33 * 0.4 F6FBB 30.07.98 Added TxTail, Slottime and Persistance
34 * 0.5 F6FBB 01.08.98 Shared IRQs, /proc/net and network statistics
35 * 0.6 F6FBB 25.08.98 Added 1200Bds format
36 * 0.7 F6FBB 12.09.98 Added to the kernel configuration
37 * 0.8 F6FBB 14.10.98 Fixed slottime/persistence timing bug
38 * OK1ZIA 2.09.01 Fixed "kfree_skb on hard IRQ"
39 * using dev_kfree_skb_any(). (important in 2.4 kernel)
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/bitops.h>
53 #include <linux/random.h>
55 #include <asm/system.h>
56 #include <linux/interrupt.h>
57 #include <linux/ioport.h>
59 #include <linux/netdevice.h>
60 #include <linux/if_arp.h>
61 #include <linux/etherdevice.h>
62 #include <linux/skbuff.h>
65 #include <linux/kernel.h>
66 #include <linux/proc_fs.h>
67 #include <linux/seq_file.h>
69 #include <asm/uaccess.h>
70 #include <linux/init.h>
72 #include <linux/yam.h>
76 /* --------------------------------------------------------------------- */
78 static const char yam_drvname
[] = "yam";
79 static char yam_drvinfo
[] __initdata
= KERN_INFO
"YAM driver version 0.8 by F1OAT/F6FBB\n";
81 /* --------------------------------------------------------------------- */
87 #define YAM_MAGIC 0xF10A7654
89 /* Transmitter states */
98 #define YAM_MAX_FRAME 1024
100 #define DEFAULT_BITRATE 9600 /* bps */
101 #define DEFAULT_HOLDD 10 /* sec */
102 #define DEFAULT_TXD 300 /* ms */
103 #define DEFAULT_TXTAIL 10 /* ms */
104 #define DEFAULT_SLOT 100 /* ms */
105 #define DEFAULT_PERS 64 /* 0->255 */
115 struct net_device
*dev
;
119 struct net_device_stats stats
;
124 /* Parameters section */
126 int txd
; /* tx delay */
127 int holdd
; /* duplex ptt delay */
128 int txtail
; /* txtail delay */
129 int slot
; /* slottime */
130 int pers
; /* persistence */
137 unsigned char tx_buf
[YAM_MAX_FRAME
];
139 int tx_crcl
, tx_crch
;
140 struct sk_buff_head send_queue
; /* Packets awaiting transmission */
145 unsigned char rx_buf
[YAM_MAX_FRAME
];
147 int rx_crcl
, rx_crch
;
151 unsigned char bits
[YAM_FPGA_SIZE
];
153 struct yam_mcs
*next
;
156 static struct net_device
*yam_devs
[NR_PORTS
];
158 static struct yam_mcs
*yam_data
;
160 static DEFINE_TIMER(yam_timer
, NULL
, 0, 0);
162 /* --------------------------------------------------------------------- */
164 #define RBR(iobase) (iobase+0)
165 #define THR(iobase) (iobase+0)
166 #define IER(iobase) (iobase+1)
167 #define IIR(iobase) (iobase+2)
168 #define FCR(iobase) (iobase+2)
169 #define LCR(iobase) (iobase+3)
170 #define MCR(iobase) (iobase+4)
171 #define LSR(iobase) (iobase+5)
172 #define MSR(iobase) (iobase+6)
173 #define SCR(iobase) (iobase+7)
174 #define DLL(iobase) (iobase+0)
175 #define DLM(iobase) (iobase+1)
179 /* Interrupt Identification Register Bit Masks */
185 #define IIR_TIMEOUT 12 /* Fifo mode only */
187 #define IIR_MASK 0x0F
189 /* Interrupt Enable Register Bit Masks */
190 #define IER_RX 1 /* enable rx interrupt */
191 #define IER_TX 2 /* enable tx interrupt */
192 #define IER_LSR 4 /* enable line status interrupts */
193 #define IER_MSR 8 /* enable modem status interrupts */
195 /* Modem Control Register Bit Masks */
196 #define MCR_DTR 0x01 /* DTR output */
197 #define MCR_RTS 0x02 /* RTS output */
198 #define MCR_OUT1 0x04 /* OUT1 output (not accessible in RS232) */
199 #define MCR_OUT2 0x08 /* Master Interrupt enable (must be set on PCs) */
200 #define MCR_LOOP 0x10 /* Loopback enable */
202 /* Modem Status Register Bit Masks */
203 #define MSR_DCTS 0x01 /* Delta CTS input */
204 #define MSR_DDSR 0x02 /* Delta DSR */
205 #define MSR_DRIN 0x04 /* Delta RI */
206 #define MSR_DDCD 0x08 /* Delta DCD */
207 #define MSR_CTS 0x10 /* CTS input */
208 #define MSR_DSR 0x20 /* DSR input */
209 #define MSR_RING 0x40 /* RI input */
210 #define MSR_DCD 0x80 /* DCD input */
212 /* line status register bit mask */
217 #define LSR_BREAK 0x10
218 #define LSR_THRE 0x20
219 #define LSR_TSRE 0x40
221 /* Line Control Register Bit Masks */
222 #define LCR_DLAB 0x80
223 #define LCR_BREAK 0x40
224 #define LCR_PZERO 0x28
225 #define LCR_PEVEN 0x18
226 #define LCR_PODD 0x08
227 #define LCR_STOP1 0x00
228 #define LCR_STOP2 0x04
229 #define LCR_BIT5 0x00
230 #define LCR_BIT6 0x02
231 #define LCR_BIT7 0x01
232 #define LCR_BIT8 0x03
234 /* YAM Modem <-> UART Port mapping */
236 #define TX_RDY MSR_DCTS /* transmitter ready to send */
237 #define RX_DCD MSR_DCD /* carrier detect */
238 #define RX_FLAG MSR_RING /* hdlc flag received */
239 #define FPGA_DONE MSR_DSR /* FPGA is configured */
240 #define PTT_ON (MCR_RTS|MCR_OUT2) /* activate PTT */
241 #define PTT_OFF (MCR_DTR|MCR_OUT2) /* release PTT */
243 #define ENABLE_RXINT IER_RX /* enable uart rx interrupt during rx */
244 #define ENABLE_TXINT IER_MSR /* enable uart ms interrupt during tx */
245 #define ENABLE_RTXINT (IER_RX|IER_MSR) /* full duplex operations */
248 /*************************************************************************
250 ************************************************************************/
252 static const unsigned char chktabl
[256] =
253 {0x00, 0x89, 0x12, 0x9b, 0x24, 0xad, 0x36, 0xbf, 0x48, 0xc1, 0x5a, 0xd3, 0x6c, 0xe5, 0x7e,
254 0xf7, 0x81, 0x08, 0x93, 0x1a, 0xa5, 0x2c, 0xb7, 0x3e, 0xc9, 0x40, 0xdb, 0x52, 0xed, 0x64,
255 0xff, 0x76, 0x02, 0x8b, 0x10, 0x99, 0x26, 0xaf, 0x34, 0xbd, 0x4a, 0xc3, 0x58, 0xd1, 0x6e,
256 0xe7, 0x7c, 0xf5, 0x83, 0x0a, 0x91, 0x18, 0xa7, 0x2e, 0xb5, 0x3c, 0xcb, 0x42, 0xd9, 0x50,
257 0xef, 0x66, 0xfd, 0x74, 0x04, 0x8d, 0x16, 0x9f, 0x20, 0xa9, 0x32, 0xbb, 0x4c, 0xc5, 0x5e,
258 0xd7, 0x68, 0xe1, 0x7a, 0xf3, 0x85, 0x0c, 0x97, 0x1e, 0xa1, 0x28, 0xb3, 0x3a, 0xcd, 0x44,
259 0xdf, 0x56, 0xe9, 0x60, 0xfb, 0x72, 0x06, 0x8f, 0x14, 0x9d, 0x22, 0xab, 0x30, 0xb9, 0x4e,
260 0xc7, 0x5c, 0xd5, 0x6a, 0xe3, 0x78, 0xf1, 0x87, 0x0e, 0x95, 0x1c, 0xa3, 0x2a, 0xb1, 0x38,
261 0xcf, 0x46, 0xdd, 0x54, 0xeb, 0x62, 0xf9, 0x70, 0x08, 0x81, 0x1a, 0x93, 0x2c, 0xa5, 0x3e,
262 0xb7, 0x40, 0xc9, 0x52, 0xdb, 0x64, 0xed, 0x76, 0xff, 0x89, 0x00, 0x9b, 0x12, 0xad, 0x24,
263 0xbf, 0x36, 0xc1, 0x48, 0xd3, 0x5a, 0xe5, 0x6c, 0xf7, 0x7e, 0x0a, 0x83, 0x18, 0x91, 0x2e,
264 0xa7, 0x3c, 0xb5, 0x42, 0xcb, 0x50, 0xd9, 0x66, 0xef, 0x74, 0xfd, 0x8b, 0x02, 0x99, 0x10,
265 0xaf, 0x26, 0xbd, 0x34, 0xc3, 0x4a, 0xd1, 0x58, 0xe7, 0x6e, 0xf5, 0x7c, 0x0c, 0x85, 0x1e,
266 0x97, 0x28, 0xa1, 0x3a, 0xb3, 0x44, 0xcd, 0x56, 0xdf, 0x60, 0xe9, 0x72, 0xfb, 0x8d, 0x04,
267 0x9f, 0x16, 0xa9, 0x20, 0xbb, 0x32, 0xc5, 0x4c, 0xd7, 0x5e, 0xe1, 0x68, 0xf3, 0x7a, 0x0e,
268 0x87, 0x1c, 0x95, 0x2a, 0xa3, 0x38, 0xb1, 0x46, 0xcf, 0x54, 0xdd, 0x62, 0xeb, 0x70, 0xf9,
269 0x8f, 0x06, 0x9d, 0x14, 0xab, 0x22, 0xb9, 0x30, 0xc7, 0x4e, 0xd5, 0x5c, 0xe3, 0x6a, 0xf1,
271 static const unsigned char chktabh
[256] =
272 {0x00, 0x11, 0x23, 0x32, 0x46, 0x57, 0x65, 0x74, 0x8c, 0x9d, 0xaf, 0xbe, 0xca, 0xdb, 0xe9,
273 0xf8, 0x10, 0x01, 0x33, 0x22, 0x56, 0x47, 0x75, 0x64, 0x9c, 0x8d, 0xbf, 0xae, 0xda, 0xcb,
274 0xf9, 0xe8, 0x21, 0x30, 0x02, 0x13, 0x67, 0x76, 0x44, 0x55, 0xad, 0xbc, 0x8e, 0x9f, 0xeb,
275 0xfa, 0xc8, 0xd9, 0x31, 0x20, 0x12, 0x03, 0x77, 0x66, 0x54, 0x45, 0xbd, 0xac, 0x9e, 0x8f,
276 0xfb, 0xea, 0xd8, 0xc9, 0x42, 0x53, 0x61, 0x70, 0x04, 0x15, 0x27, 0x36, 0xce, 0xdf, 0xed,
277 0xfc, 0x88, 0x99, 0xab, 0xba, 0x52, 0x43, 0x71, 0x60, 0x14, 0x05, 0x37, 0x26, 0xde, 0xcf,
278 0xfd, 0xec, 0x98, 0x89, 0xbb, 0xaa, 0x63, 0x72, 0x40, 0x51, 0x25, 0x34, 0x06, 0x17, 0xef,
279 0xfe, 0xcc, 0xdd, 0xa9, 0xb8, 0x8a, 0x9b, 0x73, 0x62, 0x50, 0x41, 0x35, 0x24, 0x16, 0x07,
280 0xff, 0xee, 0xdc, 0xcd, 0xb9, 0xa8, 0x9a, 0x8b, 0x84, 0x95, 0xa7, 0xb6, 0xc2, 0xd3, 0xe1,
281 0xf0, 0x08, 0x19, 0x2b, 0x3a, 0x4e, 0x5f, 0x6d, 0x7c, 0x94, 0x85, 0xb7, 0xa6, 0xd2, 0xc3,
282 0xf1, 0xe0, 0x18, 0x09, 0x3b, 0x2a, 0x5e, 0x4f, 0x7d, 0x6c, 0xa5, 0xb4, 0x86, 0x97, 0xe3,
283 0xf2, 0xc0, 0xd1, 0x29, 0x38, 0x0a, 0x1b, 0x6f, 0x7e, 0x4c, 0x5d, 0xb5, 0xa4, 0x96, 0x87,
284 0xf3, 0xe2, 0xd0, 0xc1, 0x39, 0x28, 0x1a, 0x0b, 0x7f, 0x6e, 0x5c, 0x4d, 0xc6, 0xd7, 0xe5,
285 0xf4, 0x80, 0x91, 0xa3, 0xb2, 0x4a, 0x5b, 0x69, 0x78, 0x0c, 0x1d, 0x2f, 0x3e, 0xd6, 0xc7,
286 0xf5, 0xe4, 0x90, 0x81, 0xb3, 0xa2, 0x5a, 0x4b, 0x79, 0x68, 0x1c, 0x0d, 0x3f, 0x2e, 0xe7,
287 0xf6, 0xc4, 0xd5, 0xa1, 0xb0, 0x82, 0x93, 0x6b, 0x7a, 0x48, 0x59, 0x2d, 0x3c, 0x0e, 0x1f,
288 0xf7, 0xe6, 0xd4, 0xc5, 0xb1, 0xa0, 0x92, 0x83, 0x7b, 0x6a, 0x58, 0x49, 0x3d, 0x2c, 0x1e,
291 /*************************************************************************
293 ************************************************************************/
295 static void delay(int ms
)
297 unsigned long timeout
= jiffies
+ ((ms
* HZ
) / 1000);
298 while (time_before(jiffies
, timeout
))
306 static void fpga_reset(int iobase
)
308 outb(0, IER(iobase
));
309 outb(LCR_DLAB
| LCR_BIT5
, LCR(iobase
));
310 outb(1, DLL(iobase
));
311 outb(0, DLM(iobase
));
313 outb(LCR_BIT5
, LCR(iobase
));
316 /* turn off FPGA supply voltage */
317 outb(MCR_OUT1
| MCR_OUT2
, MCR(iobase
));
319 /* turn on FPGA supply voltage again */
320 outb(MCR_DTR
| MCR_RTS
| MCR_OUT1
| MCR_OUT2
, MCR(iobase
));
325 * send one byte to FPGA
328 static int fpga_write(int iobase
, unsigned char wrd
)
332 unsigned long timeout
= jiffies
+ HZ
/ 10;
334 for (k
= 0; k
< 8; k
++) {
335 bit
= (wrd
& 0x80) ? (MCR_RTS
| MCR_DTR
) : MCR_DTR
;
336 outb(bit
| MCR_OUT1
| MCR_OUT2
, MCR(iobase
));
338 outb(0xfc, THR(iobase
));
339 while ((inb(LSR(iobase
)) & LSR_TSRE
) == 0)
340 if (time_after(jiffies
, timeout
))
347 static unsigned char *add_mcs(unsigned char *bits
, int bitrate
)
351 /* If it already exists, replace the bit data */
354 if (p
->bitrate
== bitrate
) {
355 memcpy(p
->bits
, bits
, YAM_FPGA_SIZE
);
361 /* Allocate a new mcs */
362 if ((p
= kmalloc(sizeof(struct yam_mcs
), GFP_KERNEL
)) == NULL
) {
363 printk(KERN_WARNING
"YAM: no memory to allocate mcs\n");
366 memcpy(p
->bits
, bits
, YAM_FPGA_SIZE
);
367 p
->bitrate
= bitrate
;
374 static unsigned char *get_mcs(int bitrate
)
380 if (p
->bitrate
== bitrate
)
385 /* Load predefined mcs data */
388 return add_mcs(bits_1200
, bitrate
);
390 return add_mcs(bits_9600
, bitrate
);
395 * download bitstream to FPGA
396 * data is contained in bits[] array in yam1200.h resp. yam9600.h
399 static int fpga_download(int iobase
, int bitrate
)
402 unsigned char *pbits
;
404 pbits
= get_mcs(bitrate
);
409 for (i
= 0; i
< YAM_FPGA_SIZE
; i
++) {
410 if (fpga_write(iobase
, pbits
[i
])) {
411 printk(KERN_ERR
"yam: error in write cycle\n");
412 return -1; /* write... */
416 fpga_write(iobase
, 0xFF);
417 rc
= inb(MSR(iobase
)); /* check DONE signal */
419 /* Needed for some hardwares */
422 return (rc
& MSR_DSR
) ? 0 : -1;
426 /************************************************************************
428 ************************************************************************/
430 static void yam_set_uart(struct net_device
*dev
)
432 struct yam_port
*yp
= netdev_priv(dev
);
433 int divisor
= 115200 / yp
->baudrate
;
435 outb(0, IER(dev
->base_addr
));
436 outb(LCR_DLAB
| LCR_BIT8
, LCR(dev
->base_addr
));
437 outb(divisor
, DLL(dev
->base_addr
));
438 outb(0, DLM(dev
->base_addr
));
439 outb(LCR_BIT8
, LCR(dev
->base_addr
));
440 outb(PTT_OFF
, MCR(dev
->base_addr
));
441 outb(0x00, FCR(dev
->base_addr
));
443 /* Flush pending irq */
445 inb(RBR(dev
->base_addr
));
446 inb(MSR(dev
->base_addr
));
450 outb(ENABLE_RTXINT
, IER(dev
->base_addr
));
454 /* --------------------------------------------------------------------- */
457 c_uart_unknown
, c_uart_8250
,
458 c_uart_16450
, c_uart_16550
, c_uart_16550A
461 static const char *uart_str
[] =
462 {"unknown", "8250", "16450", "16550", "16550A"};
464 static enum uart
yam_check_uart(unsigned int iobase
)
466 unsigned char b1
, b2
, b3
;
468 enum uart uart_tab
[] =
469 {c_uart_16450
, c_uart_unknown
, c_uart_16550
, c_uart_16550A
};
471 b1
= inb(MCR(iobase
));
472 outb(b1
| 0x10, MCR(iobase
)); /* loopback mode */
473 b2
= inb(MSR(iobase
));
474 outb(0x1a, MCR(iobase
));
475 b3
= inb(MSR(iobase
)) & 0xf0;
476 outb(b1
, MCR(iobase
)); /* restore old values */
477 outb(b2
, MSR(iobase
));
479 return c_uart_unknown
;
482 outb(0x01, FCR(iobase
)); /* enable FIFOs */
483 u
= uart_tab
[(inb(IIR(iobase
)) >> 6) & 3];
484 if (u
== c_uart_16450
) {
485 outb(0x5a, SCR(iobase
));
486 b1
= inb(SCR(iobase
));
487 outb(0xa5, SCR(iobase
));
488 b2
= inb(SCR(iobase
));
489 if ((b1
!= 0x5a) || (b2
!= 0xa5))
495 /******************************************************************************
497 ******************************************************************************/
498 static inline void yam_rx_flag(struct net_device
*dev
, struct yam_port
*yp
)
500 if (yp
->dcd
&& yp
->rx_len
>= 3 && yp
->rx_len
< YAM_MAX_FRAME
) {
501 int pkt_len
= yp
->rx_len
- 2 + 1; /* -CRC + kiss */
504 if ((yp
->rx_crch
& yp
->rx_crcl
) != 0xFF) {
507 if (!(skb
= dev_alloc_skb(pkt_len
))) {
508 printk(KERN_WARNING
"%s: memory squeeze, dropping packet\n", dev
->name
);
509 ++yp
->stats
.rx_dropped
;
512 cp
= skb_put(skb
, pkt_len
);
513 *cp
++ = 0; /* KISS kludge */
514 memcpy(cp
, yp
->rx_buf
, pkt_len
- 1);
515 skb
->protocol
= ax25_type_trans(skb
, dev
);
517 dev
->last_rx
= jiffies
;
518 ++yp
->stats
.rx_packets
;
527 static inline void yam_rx_byte(struct net_device
*dev
, struct yam_port
*yp
, unsigned char rxb
)
529 if (yp
->rx_len
< YAM_MAX_FRAME
) {
530 unsigned char c
= yp
->rx_crcl
;
531 yp
->rx_crcl
= (chktabl
[c
] ^ yp
->rx_crch
);
532 yp
->rx_crch
= (chktabh
[c
] ^ rxb
);
533 yp
->rx_buf
[yp
->rx_len
++] = rxb
;
537 /********************************************************************************
539 ********************************************************************************/
541 static void ptt_on(struct net_device
*dev
)
543 outb(PTT_ON
, MCR(dev
->base_addr
));
546 static void ptt_off(struct net_device
*dev
)
548 outb(PTT_OFF
, MCR(dev
->base_addr
));
551 static int yam_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
553 struct yam_port
*yp
= netdev_priv(dev
);
555 skb_queue_tail(&yp
->send_queue
, skb
);
556 dev
->trans_start
= jiffies
;
560 static void yam_start_tx(struct net_device
*dev
, struct yam_port
*yp
)
562 if ((yp
->tx_state
== TX_TAIL
) || (yp
->txd
== 0))
565 yp
->tx_count
= (yp
->bitrate
* yp
->txd
) / 8000;
566 yp
->tx_state
= TX_HEAD
;
570 static void yam_arbitrate(struct net_device
*dev
)
572 struct yam_port
*yp
= netdev_priv(dev
);
574 if (yp
->magic
!= YAM_MAGIC
|| yp
->tx_state
!= TX_OFF
||
575 skb_queue_empty(&yp
->send_queue
))
577 /* tx_state is TX_OFF and there is data to send */
580 /* Full duplex mode, don't wait */
581 yam_start_tx(dev
, yp
);
585 /* DCD on, wait slotime ... */
586 yp
->slotcnt
= yp
->slot
/ 10;
589 /* Is slottime passed ? */
590 if ((--yp
->slotcnt
) > 0)
593 yp
->slotcnt
= yp
->slot
/ 10;
595 /* is random > persist ? */
596 if ((random32() % 256) > yp
->pers
)
599 yam_start_tx(dev
, yp
);
602 static void yam_dotimer(unsigned long dummy
)
606 for (i
= 0; i
< NR_PORTS
; i
++) {
607 struct net_device
*dev
= yam_devs
[i
];
608 if (dev
&& netif_running(dev
))
611 yam_timer
.expires
= jiffies
+ HZ
/ 100;
612 add_timer(&yam_timer
);
615 static void yam_tx_byte(struct net_device
*dev
, struct yam_port
*yp
)
618 unsigned char b
, temp
;
620 switch (yp
->tx_state
) {
624 if (--yp
->tx_count
<= 0) {
625 if (!(skb
= skb_dequeue(&yp
->send_queue
))) {
627 yp
->tx_state
= TX_OFF
;
630 yp
->tx_state
= TX_DATA
;
631 if (skb
->data
[0] != 0) {
632 /* do_kiss_params(s, skb->data, skb->len); */
633 dev_kfree_skb_any(skb
);
636 yp
->tx_len
= skb
->len
- 1; /* strip KISS byte */
637 if (yp
->tx_len
>= YAM_MAX_FRAME
|| yp
->tx_len
< 2) {
638 dev_kfree_skb_any(skb
);
641 skb_copy_from_linear_data_offset(skb
->data
, 1,
644 dev_kfree_skb_any(skb
);
648 yp
->tx_state
= TX_DATA
;
652 b
= yp
->tx_buf
[yp
->tx_count
++];
653 outb(b
, THR(dev
->base_addr
));
655 yp
->tx_crcl
= chktabl
[temp
] ^ yp
->tx_crch
;
656 yp
->tx_crch
= chktabh
[temp
] ^ b
;
657 if (yp
->tx_count
>= yp
->tx_len
) {
658 yp
->tx_state
= TX_CRC1
;
662 yp
->tx_crch
= chktabl
[yp
->tx_crcl
] ^ yp
->tx_crch
;
663 yp
->tx_crcl
= chktabh
[yp
->tx_crcl
] ^ chktabl
[yp
->tx_crch
] ^ 0xff;
664 outb(yp
->tx_crcl
, THR(dev
->base_addr
));
665 yp
->tx_state
= TX_CRC2
;
668 outb(chktabh
[yp
->tx_crch
] ^ 0xFF, THR(dev
->base_addr
));
669 if (skb_queue_empty(&yp
->send_queue
)) {
670 yp
->tx_count
= (yp
->bitrate
* yp
->txtail
) / 8000;
671 if (yp
->dupmode
== 2)
672 yp
->tx_count
+= (yp
->bitrate
* yp
->holdd
) / 8;
673 if (yp
->tx_count
== 0)
675 yp
->tx_state
= TX_TAIL
;
678 yp
->tx_state
= TX_HEAD
;
680 ++yp
->stats
.tx_packets
;
683 if (--yp
->tx_count
<= 0) {
684 yp
->tx_state
= TX_OFF
;
691 /***********************************************************************************
693 ************************************************************************************/
695 static irqreturn_t
yam_interrupt(int irq
, void *dev_id
)
697 struct net_device
*dev
;
704 for (i
= 0; i
< NR_PORTS
; i
++) {
706 yp
= netdev_priv(dev
);
708 if (!netif_running(dev
))
711 while ((iir
= IIR_MASK
& inb(IIR(dev
->base_addr
))) != IIR_NOPEND
) {
712 unsigned char msr
= inb(MSR(dev
->base_addr
));
713 unsigned char lsr
= inb(LSR(dev
->base_addr
));
719 ++yp
->stats
.rx_fifo_errors
;
721 yp
->dcd
= (msr
& RX_DCD
) ? 1 : 0;
723 if (--counter
<= 0) {
724 printk(KERN_ERR
"%s: too many irq iir=%d\n",
730 yam_tx_byte(dev
, yp
);
734 rxb
= inb(RBR(dev
->base_addr
));
736 yam_rx_flag(dev
, yp
);
738 yam_rx_byte(dev
, yp
, rxb
);
743 return IRQ_RETVAL(handled
);
746 #ifdef CONFIG_PROC_FS
748 static void *yam_seq_start(struct seq_file
*seq
, loff_t
*pos
)
750 return (*pos
< NR_PORTS
) ? yam_devs
[*pos
] : NULL
;
753 static void *yam_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
756 return (*pos
< NR_PORTS
) ? yam_devs
[*pos
] : NULL
;
759 static void yam_seq_stop(struct seq_file
*seq
, void *v
)
763 static int yam_seq_show(struct seq_file
*seq
, void *v
)
765 struct net_device
*dev
= v
;
766 const struct yam_port
*yp
= netdev_priv(dev
);
768 seq_printf(seq
, "Device %s\n", dev
->name
);
769 seq_printf(seq
, " Up %d\n", netif_running(dev
));
770 seq_printf(seq
, " Speed %u\n", yp
->bitrate
);
771 seq_printf(seq
, " IoBase 0x%x\n", yp
->iobase
);
772 seq_printf(seq
, " BaudRate %u\n", yp
->baudrate
);
773 seq_printf(seq
, " IRQ %u\n", yp
->irq
);
774 seq_printf(seq
, " TxState %u\n", yp
->tx_state
);
775 seq_printf(seq
, " Duplex %u\n", yp
->dupmode
);
776 seq_printf(seq
, " HoldDly %u\n", yp
->holdd
);
777 seq_printf(seq
, " TxDelay %u\n", yp
->txd
);
778 seq_printf(seq
, " TxTail %u\n", yp
->txtail
);
779 seq_printf(seq
, " SlotTime %u\n", yp
->slot
);
780 seq_printf(seq
, " Persist %u\n", yp
->pers
);
781 seq_printf(seq
, " TxFrames %lu\n", yp
->stats
.tx_packets
);
782 seq_printf(seq
, " RxFrames %lu\n", yp
->stats
.rx_packets
);
783 seq_printf(seq
, " TxInt %u\n", yp
->nb_mdint
);
784 seq_printf(seq
, " RxInt %u\n", yp
->nb_rxint
);
785 seq_printf(seq
, " RxOver %lu\n", yp
->stats
.rx_fifo_errors
);
786 seq_printf(seq
, "\n");
790 static struct seq_operations yam_seqops
= {
791 .start
= yam_seq_start
,
792 .next
= yam_seq_next
,
793 .stop
= yam_seq_stop
,
794 .show
= yam_seq_show
,
797 static int yam_info_open(struct inode
*inode
, struct file
*file
)
799 return seq_open(file
, &yam_seqops
);
802 static const struct file_operations yam_info_fops
= {
803 .owner
= THIS_MODULE
,
804 .open
= yam_info_open
,
807 .release
= seq_release
,
813 /* --------------------------------------------------------------------- */
815 static struct net_device_stats
*yam_get_stats(struct net_device
*dev
)
822 yp
= netdev_priv(dev
);
823 if (yp
->magic
!= YAM_MAGIC
)
827 * Get the current statistics. This may be called with the
828 * card open or closed.
833 /* --------------------------------------------------------------------- */
835 static int yam_open(struct net_device
*dev
)
837 struct yam_port
*yp
= netdev_priv(dev
);
842 printk(KERN_INFO
"Trying %s at iobase 0x%lx irq %u\n", dev
->name
, dev
->base_addr
, dev
->irq
);
844 if (!dev
|| !yp
->bitrate
)
846 if (!dev
->base_addr
|| dev
->base_addr
> 0x1000 - YAM_EXTENT
||
847 dev
->irq
< 2 || dev
->irq
> 15) {
850 if (!request_region(dev
->base_addr
, YAM_EXTENT
, dev
->name
))
852 printk(KERN_ERR
"%s: cannot 0x%lx busy\n", dev
->name
, dev
->base_addr
);
855 if ((u
= yam_check_uart(dev
->base_addr
)) == c_uart_unknown
) {
856 printk(KERN_ERR
"%s: cannot find uart type\n", dev
->name
);
858 goto out_release_base
;
860 if (fpga_download(dev
->base_addr
, yp
->bitrate
)) {
861 printk(KERN_ERR
"%s: cannot init FPGA\n", dev
->name
);
863 goto out_release_base
;
865 outb(0, IER(dev
->base_addr
));
866 if (request_irq(dev
->irq
, yam_interrupt
, IRQF_DISABLED
| IRQF_SHARED
, dev
->name
, dev
)) {
867 printk(KERN_ERR
"%s: irq %d busy\n", dev
->name
, dev
->irq
);
869 goto out_release_base
;
874 netif_start_queue(dev
);
876 yp
->slotcnt
= yp
->slot
/ 10;
878 /* Reset overruns for all ports - FPGA programming makes overruns */
879 for (i
= 0; i
< NR_PORTS
; i
++) {
880 struct net_device
*dev
= yam_devs
[i
];
881 struct yam_port
*yp
= netdev_priv(dev
);
882 inb(LSR(dev
->base_addr
));
883 yp
->stats
.rx_fifo_errors
= 0;
886 printk(KERN_INFO
"%s at iobase 0x%lx irq %u uart %s\n", dev
->name
, dev
->base_addr
, dev
->irq
,
891 release_region(dev
->base_addr
, YAM_EXTENT
);
895 /* --------------------------------------------------------------------- */
897 static int yam_close(struct net_device
*dev
)
900 struct yam_port
*yp
= netdev_priv(dev
);
908 outb(0, IER(dev
->base_addr
));
909 outb(1, MCR(dev
->base_addr
));
910 /* Remove IRQ handler if last */
911 free_irq(dev
->irq
,dev
);
912 release_region(dev
->base_addr
, YAM_EXTENT
);
913 netif_stop_queue(dev
);
914 while ((skb
= skb_dequeue(&yp
->send_queue
)))
917 printk(KERN_INFO
"%s: close yam at iobase 0x%lx irq %u\n",
918 yam_drvname
, dev
->base_addr
, dev
->irq
);
922 /* --------------------------------------------------------------------- */
924 static int yam_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
926 struct yam_port
*yp
= netdev_priv(dev
);
927 struct yamdrv_ioctl_cfg yi
;
928 struct yamdrv_ioctl_mcs
*ym
;
931 if (copy_from_user(&ioctl_cmd
, ifr
->ifr_data
, sizeof(int)))
934 if (yp
->magic
!= YAM_MAGIC
)
937 if (!capable(CAP_NET_ADMIN
))
940 if (cmd
!= SIOCDEVPRIVATE
)
945 case SIOCYAMRESERVED
:
946 return -EINVAL
; /* unused */
949 if (netif_running(dev
))
950 return -EINVAL
; /* Cannot change this parameter when up */
951 if ((ym
= kmalloc(sizeof(struct yamdrv_ioctl_mcs
), GFP_KERNEL
)) == NULL
)
954 if (copy_from_user(ym
, ifr
->ifr_data
, sizeof(struct yamdrv_ioctl_mcs
))) {
958 if (ym
->bitrate
> YAM_MAXBITRATE
) {
962 add_mcs(ym
->bits
, ym
->bitrate
);
967 if (!capable(CAP_SYS_RAWIO
))
969 if (copy_from_user(&yi
, ifr
->ifr_data
, sizeof(struct yamdrv_ioctl_cfg
)))
972 if ((yi
.cfg
.mask
& YAM_IOBASE
) && netif_running(dev
))
973 return -EINVAL
; /* Cannot change this parameter when up */
974 if ((yi
.cfg
.mask
& YAM_IRQ
) && netif_running(dev
))
975 return -EINVAL
; /* Cannot change this parameter when up */
976 if ((yi
.cfg
.mask
& YAM_BITRATE
) && netif_running(dev
))
977 return -EINVAL
; /* Cannot change this parameter when up */
978 if ((yi
.cfg
.mask
& YAM_BAUDRATE
) && netif_running(dev
))
979 return -EINVAL
; /* Cannot change this parameter when up */
981 if (yi
.cfg
.mask
& YAM_IOBASE
) {
982 yp
->iobase
= yi
.cfg
.iobase
;
983 dev
->base_addr
= yi
.cfg
.iobase
;
985 if (yi
.cfg
.mask
& YAM_IRQ
) {
988 yp
->irq
= yi
.cfg
.irq
;
989 dev
->irq
= yi
.cfg
.irq
;
991 if (yi
.cfg
.mask
& YAM_BITRATE
) {
992 if (yi
.cfg
.bitrate
> YAM_MAXBITRATE
)
994 yp
->bitrate
= yi
.cfg
.bitrate
;
996 if (yi
.cfg
.mask
& YAM_BAUDRATE
) {
997 if (yi
.cfg
.baudrate
> YAM_MAXBAUDRATE
)
999 yp
->baudrate
= yi
.cfg
.baudrate
;
1001 if (yi
.cfg
.mask
& YAM_MODE
) {
1002 if (yi
.cfg
.mode
> YAM_MAXMODE
)
1004 yp
->dupmode
= yi
.cfg
.mode
;
1006 if (yi
.cfg
.mask
& YAM_HOLDDLY
) {
1007 if (yi
.cfg
.holddly
> YAM_MAXHOLDDLY
)
1009 yp
->holdd
= yi
.cfg
.holddly
;
1011 if (yi
.cfg
.mask
& YAM_TXDELAY
) {
1012 if (yi
.cfg
.txdelay
> YAM_MAXTXDELAY
)
1014 yp
->txd
= yi
.cfg
.txdelay
;
1016 if (yi
.cfg
.mask
& YAM_TXTAIL
) {
1017 if (yi
.cfg
.txtail
> YAM_MAXTXTAIL
)
1019 yp
->txtail
= yi
.cfg
.txtail
;
1021 if (yi
.cfg
.mask
& YAM_PERSIST
) {
1022 if (yi
.cfg
.persist
> YAM_MAXPERSIST
)
1024 yp
->pers
= yi
.cfg
.persist
;
1026 if (yi
.cfg
.mask
& YAM_SLOTTIME
) {
1027 if (yi
.cfg
.slottime
> YAM_MAXSLOTTIME
)
1029 yp
->slot
= yi
.cfg
.slottime
;
1030 yp
->slotcnt
= yp
->slot
/ 10;
1035 yi
.cfg
.mask
= 0xffffffff;
1036 yi
.cfg
.iobase
= yp
->iobase
;
1037 yi
.cfg
.irq
= yp
->irq
;
1038 yi
.cfg
.bitrate
= yp
->bitrate
;
1039 yi
.cfg
.baudrate
= yp
->baudrate
;
1040 yi
.cfg
.mode
= yp
->dupmode
;
1041 yi
.cfg
.txdelay
= yp
->txd
;
1042 yi
.cfg
.holddly
= yp
->holdd
;
1043 yi
.cfg
.txtail
= yp
->txtail
;
1044 yi
.cfg
.persist
= yp
->pers
;
1045 yi
.cfg
.slottime
= yp
->slot
;
1046 if (copy_to_user(ifr
->ifr_data
, &yi
, sizeof(struct yamdrv_ioctl_cfg
)))
1058 /* --------------------------------------------------------------------- */
1060 static int yam_set_mac_address(struct net_device
*dev
, void *addr
)
1062 struct sockaddr
*sa
= (struct sockaddr
*) addr
;
1064 /* addr is an AX.25 shifted ASCII mac address */
1065 memcpy(dev
->dev_addr
, sa
->sa_data
, dev
->addr_len
);
1069 /* --------------------------------------------------------------------- */
1071 static void yam_setup(struct net_device
*dev
)
1073 struct yam_port
*yp
= netdev_priv(dev
);
1075 yp
->magic
= YAM_MAGIC
;
1076 yp
->bitrate
= DEFAULT_BITRATE
;
1077 yp
->baudrate
= DEFAULT_BITRATE
* 2;
1081 yp
->holdd
= DEFAULT_HOLDD
;
1082 yp
->txd
= DEFAULT_TXD
;
1083 yp
->txtail
= DEFAULT_TXTAIL
;
1084 yp
->slot
= DEFAULT_SLOT
;
1085 yp
->pers
= DEFAULT_PERS
;
1088 dev
->base_addr
= yp
->iobase
;
1091 dev
->open
= yam_open
;
1092 dev
->stop
= yam_close
;
1093 dev
->do_ioctl
= yam_ioctl
;
1094 dev
->hard_start_xmit
= yam_send_packet
;
1095 dev
->get_stats
= yam_get_stats
;
1097 skb_queue_head_init(&yp
->send_queue
);
1099 dev
->hard_header
= ax25_hard_header
;
1100 dev
->rebuild_header
= ax25_rebuild_header
;
1102 dev
->set_mac_address
= yam_set_mac_address
;
1104 dev
->type
= ARPHRD_AX25
;
1105 dev
->hard_header_len
= AX25_MAX_HEADER_LEN
;
1106 dev
->mtu
= AX25_MTU
;
1107 dev
->addr_len
= AX25_ADDR_LEN
;
1108 memcpy(dev
->broadcast
, &ax25_bcast
, AX25_ADDR_LEN
);
1109 memcpy(dev
->dev_addr
, &ax25_defaddr
, AX25_ADDR_LEN
);
1112 static int __init
yam_init_driver(void)
1114 struct net_device
*dev
;
1116 char name
[IFNAMSIZ
];
1118 printk(yam_drvinfo
);
1120 for (i
= 0; i
< NR_PORTS
; i
++) {
1121 sprintf(name
, "yam%d", i
);
1123 dev
= alloc_netdev(sizeof(struct yam_port
), name
,
1126 printk(KERN_ERR
"yam: cannot allocate net device %s\n",
1132 err
= register_netdev(dev
);
1134 printk(KERN_WARNING
"yam: cannot register net device %s\n", dev
->name
);
1141 yam_timer
.function
= yam_dotimer
;
1142 yam_timer
.expires
= jiffies
+ HZ
/ 100;
1143 add_timer(&yam_timer
);
1145 proc_net_fops_create("yam", S_IRUGO
, &yam_info_fops
);
1149 unregister_netdev(yam_devs
[i
]);
1150 free_netdev(yam_devs
[i
]);
1155 /* --------------------------------------------------------------------- */
1157 static void __exit
yam_cleanup_driver(void)
1162 del_timer(&yam_timer
);
1163 for (i
= 0; i
< NR_PORTS
; i
++) {
1164 struct net_device
*dev
= yam_devs
[i
];
1166 unregister_netdev(dev
);
1173 yam_data
= yam_data
->next
;
1177 proc_net_remove("yam");
1180 /* --------------------------------------------------------------------- */
1182 MODULE_AUTHOR("Frederic Rible F1OAT frible@teaser.fr");
1183 MODULE_DESCRIPTION("Yam amateur radio modem driver");
1184 MODULE_LICENSE("GPL");
1186 module_init(yam_init_driver
);
1187 module_exit(yam_cleanup_driver
);
1189 /* --------------------------------------------------------------------- */