?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.17.7
[linux/fpc-iii.git] / drivers / net / hamradio / yam.c
blobb49884048caa29df1cb6f09764e1528a0d99c79b
1 /*****************************************************************************/
2
3 /*
4 * yam.c -- YAM radio modem driver.
5 *
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)
8 *
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.
13 *
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.
18 *
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.
22 *
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.
26 *
27 *
28 * History:
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)
40 *
41 */
42
43 /*****************************************************************************/
44
45 #include <linux/config.h>
46 #include <linux/module.h>
47 #include <linux/types.h>
48 #include <linux/net.h>
49 #include <linux/in.h>
50 #include <linux/if.h>
51 #include <linux/slab.h>
52 #include <linux/errno.h>
53 #include <linux/bitops.h>
54 #include <asm/io.h>
55 #include <asm/system.h>
56 #include <linux/interrupt.h>
57 #include <linux/ioport.h>
58
59 #include <linux/netdevice.h>
60 #include <linux/if_arp.h>
61 #include <linux/etherdevice.h>
62 #include <linux/skbuff.h>
63 #include <net/ax25.h>
64
65 #include <linux/kernel.h>
66 #include <linux/proc_fs.h>
67 #include <linux/seq_file.h>
68
69 #include <asm/uaccess.h>
70 #include <linux/init.h>
71
72 #include <linux/yam.h>
73 #include "yam9600.h"
74 #include "yam1200.h"
75
76 /* --------------------------------------------------------------------- */
77
78 static const char yam_drvname[] = "yam";
79 static char yam_drvinfo[] __initdata = KERN_INFO "YAM driver version 0.8 by F1OAT/F6FBB\n";
80
81 /* --------------------------------------------------------------------- */
82
83 #define YAM_9600 1
84 #define YAM_1200 2
85
86 #define NR_PORTS 4
87 #define YAM_MAGIC 0xF10A7654
88
89 /* Transmitter states */
90
91 #define TX_OFF 0
92 #define TX_HEAD 1
93 #define TX_DATA 2
94 #define TX_CRC1 3
95 #define TX_CRC2 4
96 #define TX_TAIL 5
97
98 #define YAM_MAX_FRAME 1024
99
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 */
106
107 struct yam_port {
108 int magic;
109 int bitrate;
110 int baudrate;
111 int iobase;
112 int irq;
113 int dupmode;
114
115 struct net_device *dev;
116
117 /* Stats section */
118
119 struct net_device_stats stats;
120
121 int nb_rxint;
122 int nb_mdint;
123
124 /* Parameters section */
125
126 int txd; /* tx delay */
127 int holdd; /* duplex ptt delay */
128 int txtail; /* txtail delay */
129 int slot; /* slottime */
130 int pers; /* persistence */
131
132 /* Tx section */
133
134 int tx_state;
135 int tx_count;
136 int slotcnt;
137 unsigned char tx_buf[YAM_MAX_FRAME];
138 int tx_len;
139 int tx_crcl, tx_crch;
140 struct sk_buff_head send_queue; /* Packets awaiting transmission */
141
142 /* Rx section */
143
144 int dcd;
145 unsigned char rx_buf[YAM_MAX_FRAME];
146 int rx_len;
147 int rx_crcl, rx_crch;
148 };
149
150 struct yam_mcs {
151 unsigned char bits[YAM_FPGA_SIZE];
152 int bitrate;
153 struct yam_mcs *next;
154 };
155
156 static struct net_device *yam_devs[NR_PORTS];
157
158 static struct yam_mcs *yam_data;
159
160 static char ax25_bcast[7] =
161 {'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1};
162 static char ax25_test[7] =
163 {'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1};
164
165 static DEFINE_TIMER(yam_timer, NULL, 0, 0);
166
167 /* --------------------------------------------------------------------- */
168
169 #define RBR(iobase) (iobase+0)
170 #define THR(iobase) (iobase+0)
171 #define IER(iobase) (iobase+1)
172 #define IIR(iobase) (iobase+2)
173 #define FCR(iobase) (iobase+2)
174 #define LCR(iobase) (iobase+3)
175 #define MCR(iobase) (iobase+4)
176 #define LSR(iobase) (iobase+5)
177 #define MSR(iobase) (iobase+6)
178 #define SCR(iobase) (iobase+7)
179 #define DLL(iobase) (iobase+0)
180 #define DLM(iobase) (iobase+1)
181
182 #define YAM_EXTENT 8
183
184 /* Interrupt Identification Register Bit Masks */
185 #define IIR_NOPEND 1
186 #define IIR_MSR 0
187 #define IIR_TX 2
188 #define IIR_RX 4
189 #define IIR_LSR 6
190 #define IIR_TIMEOUT 12 /* Fifo mode only */
191
192 #define IIR_MASK 0x0F
193
194 /* Interrupt Enable Register Bit Masks */
195 #define IER_RX 1 /* enable rx interrupt */
196 #define IER_TX 2 /* enable tx interrupt */
197 #define IER_LSR 4 /* enable line status interrupts */
198 #define IER_MSR 8 /* enable modem status interrupts */
199
200 /* Modem Control Register Bit Masks */
201 #define MCR_DTR 0x01 /* DTR output */
202 #define MCR_RTS 0x02 /* RTS output */
203 #define MCR_OUT1 0x04 /* OUT1 output (not accessible in RS232) */
204 #define MCR_OUT2 0x08 /* Master Interrupt enable (must be set on PCs) */
205 #define MCR_LOOP 0x10 /* Loopback enable */
206
207 /* Modem Status Register Bit Masks */
208 #define MSR_DCTS 0x01 /* Delta CTS input */
209 #define MSR_DDSR 0x02 /* Delta DSR */
210 #define MSR_DRIN 0x04 /* Delta RI */
211 #define MSR_DDCD 0x08 /* Delta DCD */
212 #define MSR_CTS 0x10 /* CTS input */
213 #define MSR_DSR 0x20 /* DSR input */
214 #define MSR_RING 0x40 /* RI input */
215 #define MSR_DCD 0x80 /* DCD input */
216
217 /* line status register bit mask */
218 #define LSR_RXC 0x01
219 #define LSR_OE 0x02
220 #define LSR_PE 0x04
221 #define LSR_FE 0x08
222 #define LSR_BREAK 0x10
223 #define LSR_THRE 0x20
224 #define LSR_TSRE 0x40
225
226 /* Line Control Register Bit Masks */
227 #define LCR_DLAB 0x80
228 #define LCR_BREAK 0x40
229 #define LCR_PZERO 0x28
230 #define LCR_PEVEN 0x18
231 #define LCR_PODD 0x08
232 #define LCR_STOP1 0x00
233 #define LCR_STOP2 0x04
234 #define LCR_BIT5 0x00
235 #define LCR_BIT6 0x02
236 #define LCR_BIT7 0x01
237 #define LCR_BIT8 0x03
238
239 /* YAM Modem <-> UART Port mapping */
240
241 #define TX_RDY MSR_DCTS /* transmitter ready to send */
242 #define RX_DCD MSR_DCD /* carrier detect */
243 #define RX_FLAG MSR_RING /* hdlc flag received */
244 #define FPGA_DONE MSR_DSR /* FPGA is configured */
245 #define PTT_ON (MCR_RTS|MCR_OUT2) /* activate PTT */
246 #define PTT_OFF (MCR_DTR|MCR_OUT2) /* release PTT */
247
248 #define ENABLE_RXINT IER_RX /* enable uart rx interrupt during rx */
249 #define ENABLE_TXINT IER_MSR /* enable uart ms interrupt during tx */
250 #define ENABLE_RTXINT (IER_RX|IER_MSR) /* full duplex operations */
251
252
253 /*************************************************************************
254 * CRC Tables
255 ************************************************************************/
256
257 static const unsigned char chktabl[256] =
258 {0x00, 0x89, 0x12, 0x9b, 0x24, 0xad, 0x36, 0xbf, 0x48, 0xc1, 0x5a, 0xd3, 0x6c, 0xe5, 0x7e,
259 0xf7, 0x81, 0x08, 0x93, 0x1a, 0xa5, 0x2c, 0xb7, 0x3e, 0xc9, 0x40, 0xdb, 0x52, 0xed, 0x64,
260 0xff, 0x76, 0x02, 0x8b, 0x10, 0x99, 0x26, 0xaf, 0x34, 0xbd, 0x4a, 0xc3, 0x58, 0xd1, 0x6e,
261 0xe7, 0x7c, 0xf5, 0x83, 0x0a, 0x91, 0x18, 0xa7, 0x2e, 0xb5, 0x3c, 0xcb, 0x42, 0xd9, 0x50,
262 0xef, 0x66, 0xfd, 0x74, 0x04, 0x8d, 0x16, 0x9f, 0x20, 0xa9, 0x32, 0xbb, 0x4c, 0xc5, 0x5e,
263 0xd7, 0x68, 0xe1, 0x7a, 0xf3, 0x85, 0x0c, 0x97, 0x1e, 0xa1, 0x28, 0xb3, 0x3a, 0xcd, 0x44,
264 0xdf, 0x56, 0xe9, 0x60, 0xfb, 0x72, 0x06, 0x8f, 0x14, 0x9d, 0x22, 0xab, 0x30, 0xb9, 0x4e,
265 0xc7, 0x5c, 0xd5, 0x6a, 0xe3, 0x78, 0xf1, 0x87, 0x0e, 0x95, 0x1c, 0xa3, 0x2a, 0xb1, 0x38,
266 0xcf, 0x46, 0xdd, 0x54, 0xeb, 0x62, 0xf9, 0x70, 0x08, 0x81, 0x1a, 0x93, 0x2c, 0xa5, 0x3e,
267 0xb7, 0x40, 0xc9, 0x52, 0xdb, 0x64, 0xed, 0x76, 0xff, 0x89, 0x00, 0x9b, 0x12, 0xad, 0x24,
268 0xbf, 0x36, 0xc1, 0x48, 0xd3, 0x5a, 0xe5, 0x6c, 0xf7, 0x7e, 0x0a, 0x83, 0x18, 0x91, 0x2e,
269 0xa7, 0x3c, 0xb5, 0x42, 0xcb, 0x50, 0xd9, 0x66, 0xef, 0x74, 0xfd, 0x8b, 0x02, 0x99, 0x10,
270 0xaf, 0x26, 0xbd, 0x34, 0xc3, 0x4a, 0xd1, 0x58, 0xe7, 0x6e, 0xf5, 0x7c, 0x0c, 0x85, 0x1e,
271 0x97, 0x28, 0xa1, 0x3a, 0xb3, 0x44, 0xcd, 0x56, 0xdf, 0x60, 0xe9, 0x72, 0xfb, 0x8d, 0x04,
272 0x9f, 0x16, 0xa9, 0x20, 0xbb, 0x32, 0xc5, 0x4c, 0xd7, 0x5e, 0xe1, 0x68, 0xf3, 0x7a, 0x0e,
273 0x87, 0x1c, 0x95, 0x2a, 0xa3, 0x38, 0xb1, 0x46, 0xcf, 0x54, 0xdd, 0x62, 0xeb, 0x70, 0xf9,
274 0x8f, 0x06, 0x9d, 0x14, 0xab, 0x22, 0xb9, 0x30, 0xc7, 0x4e, 0xd5, 0x5c, 0xe3, 0x6a, 0xf1,
275 0x78};
276 static const unsigned char chktabh[256] =
277 {0x00, 0x11, 0x23, 0x32, 0x46, 0x57, 0x65, 0x74, 0x8c, 0x9d, 0xaf, 0xbe, 0xca, 0xdb, 0xe9,
278 0xf8, 0x10, 0x01, 0x33, 0x22, 0x56, 0x47, 0x75, 0x64, 0x9c, 0x8d, 0xbf, 0xae, 0xda, 0xcb,
279 0xf9, 0xe8, 0x21, 0x30, 0x02, 0x13, 0x67, 0x76, 0x44, 0x55, 0xad, 0xbc, 0x8e, 0x9f, 0xeb,
280 0xfa, 0xc8, 0xd9, 0x31, 0x20, 0x12, 0x03, 0x77, 0x66, 0x54, 0x45, 0xbd, 0xac, 0x9e, 0x8f,
281 0xfb, 0xea, 0xd8, 0xc9, 0x42, 0x53, 0x61, 0x70, 0x04, 0x15, 0x27, 0x36, 0xce, 0xdf, 0xed,
282 0xfc, 0x88, 0x99, 0xab, 0xba, 0x52, 0x43, 0x71, 0x60, 0x14, 0x05, 0x37, 0x26, 0xde, 0xcf,
283 0xfd, 0xec, 0x98, 0x89, 0xbb, 0xaa, 0x63, 0x72, 0x40, 0x51, 0x25, 0x34, 0x06, 0x17, 0xef,
284 0xfe, 0xcc, 0xdd, 0xa9, 0xb8, 0x8a, 0x9b, 0x73, 0x62, 0x50, 0x41, 0x35, 0x24, 0x16, 0x07,
285 0xff, 0xee, 0xdc, 0xcd, 0xb9, 0xa8, 0x9a, 0x8b, 0x84, 0x95, 0xa7, 0xb6, 0xc2, 0xd3, 0xe1,
286 0xf0, 0x08, 0x19, 0x2b, 0x3a, 0x4e, 0x5f, 0x6d, 0x7c, 0x94, 0x85, 0xb7, 0xa6, 0xd2, 0xc3,
287 0xf1, 0xe0, 0x18, 0x09, 0x3b, 0x2a, 0x5e, 0x4f, 0x7d, 0x6c, 0xa5, 0xb4, 0x86, 0x97, 0xe3,
288 0xf2, 0xc0, 0xd1, 0x29, 0x38, 0x0a, 0x1b, 0x6f, 0x7e, 0x4c, 0x5d, 0xb5, 0xa4, 0x96, 0x87,
289 0xf3, 0xe2, 0xd0, 0xc1, 0x39, 0x28, 0x1a, 0x0b, 0x7f, 0x6e, 0x5c, 0x4d, 0xc6, 0xd7, 0xe5,
290 0xf4, 0x80, 0x91, 0xa3, 0xb2, 0x4a, 0x5b, 0x69, 0x78, 0x0c, 0x1d, 0x2f, 0x3e, 0xd6, 0xc7,
291 0xf5, 0xe4, 0x90, 0x81, 0xb3, 0xa2, 0x5a, 0x4b, 0x79, 0x68, 0x1c, 0x0d, 0x3f, 0x2e, 0xe7,
292 0xf6, 0xc4, 0xd5, 0xa1, 0xb0, 0x82, 0x93, 0x6b, 0x7a, 0x48, 0x59, 0x2d, 0x3c, 0x0e, 0x1f,
293 0xf7, 0xe6, 0xd4, 0xc5, 0xb1, 0xa0, 0x92, 0x83, 0x7b, 0x6a, 0x58, 0x49, 0x3d, 0x2c, 0x1e,
294 0x0f};
295
296 /*************************************************************************
297 * FPGA functions
298 ************************************************************************/
299
300 static void delay(int ms)
301 {
302 unsigned long timeout = jiffies + ((ms * HZ) / 1000);
303 while (time_before(jiffies, timeout))
304 cpu_relax();
305 }
306
307 /*
308 * reset FPGA
309 */
310
311 static void fpga_reset(int iobase)
312 {
313 outb(0, IER(iobase));
314 outb(LCR_DLAB | LCR_BIT5, LCR(iobase));
315 outb(1, DLL(iobase));
316 outb(0, DLM(iobase));
317
318 outb(LCR_BIT5, LCR(iobase));
319 inb(LSR(iobase));
320 inb(MSR(iobase));
321 /* turn off FPGA supply voltage */
322 outb(MCR_OUT1 | MCR_OUT2, MCR(iobase));
323 delay(100);
324 /* turn on FPGA supply voltage again */
325 outb(MCR_DTR | MCR_RTS | MCR_OUT1 | MCR_OUT2, MCR(iobase));
326 delay(100);
327 }
328
329 /*
330 * send one byte to FPGA
331 */
332
333 static int fpga_write(int iobase, unsigned char wrd)
334 {
335 unsigned char bit;
336 int k;
337 unsigned long timeout = jiffies + HZ / 10;
338
339 for (k = 0; k < 8; k++) {
340 bit = (wrd & 0x80) ? (MCR_RTS | MCR_DTR) : MCR_DTR;
341 outb(bit | MCR_OUT1 | MCR_OUT2, MCR(iobase));
342 wrd <<= 1;
343 outb(0xfc, THR(iobase));
344 while ((inb(LSR(iobase)) & LSR_TSRE) == 0)
345 if (time_after(jiffies, timeout))
346 return -1;
347 }
348
349 return 0;
350 }
351
352 static unsigned char *add_mcs(unsigned char *bits, int bitrate)
353 {
354 struct yam_mcs *p;
355
356 /* If it already exists, replace the bit data */
357 p = yam_data;
358 while (p) {
359 if (p->bitrate == bitrate) {
360 memcpy(p->bits, bits, YAM_FPGA_SIZE);
361 return p->bits;
362 }
363 p = p->next;
364 }
365
366 /* Allocate a new mcs */
367 if ((p = kmalloc(sizeof(struct yam_mcs), GFP_KERNEL)) == NULL) {
368 printk(KERN_WARNING "YAM: no memory to allocate mcs\n");
369 return NULL;
370 }
371 memcpy(p->bits, bits, YAM_FPGA_SIZE);
372 p->bitrate = bitrate;
373 p->next = yam_data;
374 yam_data = p;
375
376 return p->bits;
377 }
378
379 static unsigned char *get_mcs(int bitrate)
380 {
381 struct yam_mcs *p;
382
383 p = yam_data;
384 while (p) {
385 if (p->bitrate == bitrate)
386 return p->bits;
387 p = p->next;
388 }
389
390 /* Load predefined mcs data */
391 switch (bitrate) {
392 case 1200:
393 return add_mcs(bits_1200, bitrate);
394 default:
395 return add_mcs(bits_9600, bitrate);
396 }
397 }
398
399 /*
400 * download bitstream to FPGA
401 * data is contained in bits[] array in yam1200.h resp. yam9600.h
402 */
403
404 static int fpga_download(int iobase, int bitrate)
405 {
406 int i, rc;
407 unsigned char *pbits;
408
409 pbits = get_mcs(bitrate);
410 if (pbits == NULL)
411 return -1;
412
413 fpga_reset(iobase);
414 for (i = 0; i < YAM_FPGA_SIZE; i++) {
415 if (fpga_write(iobase, pbits[i])) {
416 printk(KERN_ERR "yam: error in write cycle\n");
417 return -1; /* write... */
418 }
419 }
420
421 fpga_write(iobase, 0xFF);
422 rc = inb(MSR(iobase)); /* check DONE signal */
423
424 /* Needed for some hardwares */
425 delay(50);
426
427 return (rc & MSR_DSR) ? 0 : -1;
428 }
429
430
431 /************************************************************************
432 * Serial port init
433 ************************************************************************/
434
435 static void yam_set_uart(struct net_device *dev)
436 {
437 struct yam_port *yp = netdev_priv(dev);
438 int divisor = 115200 / yp->baudrate;
439
440 outb(0, IER(dev->base_addr));
441 outb(LCR_DLAB | LCR_BIT8, LCR(dev->base_addr));
442 outb(divisor, DLL(dev->base_addr));
443 outb(0, DLM(dev->base_addr));
444 outb(LCR_BIT8, LCR(dev->base_addr));
445 outb(PTT_OFF, MCR(dev->base_addr));
446 outb(0x00, FCR(dev->base_addr));
447
448 /* Flush pending irq */
449
450 inb(RBR(dev->base_addr));
451 inb(MSR(dev->base_addr));
452
453 /* Enable rx irq */
454
455 outb(ENABLE_RTXINT, IER(dev->base_addr));
456 }
457
458
459 /* --------------------------------------------------------------------- */
460
461 enum uart {
462 c_uart_unknown, c_uart_8250,
463 c_uart_16450, c_uart_16550, c_uart_16550A
464 };
465
466 static const char *uart_str[] =
467 {"unknown", "8250", "16450", "16550", "16550A"};
468
469 static enum uart yam_check_uart(unsigned int iobase)
470 {
471 unsigned char b1, b2, b3;
472 enum uart u;
473 enum uart uart_tab[] =
474 {c_uart_16450, c_uart_unknown, c_uart_16550, c_uart_16550A};
475
476 b1 = inb(MCR(iobase));
477 outb(b1 | 0x10, MCR(iobase)); /* loopback mode */
478 b2 = inb(MSR(iobase));
479 outb(0x1a, MCR(iobase));
480 b3 = inb(MSR(iobase)) & 0xf0;
481 outb(b1, MCR(iobase)); /* restore old values */
482 outb(b2, MSR(iobase));
483 if (b3 != 0x90)
484 return c_uart_unknown;
485 inb(RBR(iobase));
486 inb(RBR(iobase));
487 outb(0x01, FCR(iobase)); /* enable FIFOs */
488 u = uart_tab[(inb(IIR(iobase)) >> 6) & 3];
489 if (u == c_uart_16450) {
490 outb(0x5a, SCR(iobase));
491 b1 = inb(SCR(iobase));
492 outb(0xa5, SCR(iobase));
493 b2 = inb(SCR(iobase));
494 if ((b1 != 0x5a) || (b2 != 0xa5))
495 u = c_uart_8250;
496 }
497 return u;
498 }
499
500 /******************************************************************************
501 * Rx Section
502 ******************************************************************************/
503 static inline void yam_rx_flag(struct net_device *dev, struct yam_port *yp)
504 {
505 if (yp->dcd && yp->rx_len >= 3 && yp->rx_len < YAM_MAX_FRAME) {
506 int pkt_len = yp->rx_len - 2 + 1; /* -CRC + kiss */
507 struct sk_buff *skb;
508
509 if ((yp->rx_crch & yp->rx_crcl) != 0xFF) {
510 /* Bad crc */
511 } else {
512 if (!(skb = dev_alloc_skb(pkt_len))) {
513 printk(KERN_WARNING "%s: memory squeeze, dropping packet\n", dev->name);
514 ++yp->stats.rx_dropped;
515 } else {
516 unsigned char *cp;
517 cp = skb_put(skb, pkt_len);
518 *cp++ = 0; /* KISS kludge */
519 memcpy(cp, yp->rx_buf, pkt_len - 1);
520 skb->protocol = ax25_type_trans(skb, dev);
521 netif_rx(skb);
522 dev->last_rx = jiffies;
523 ++yp->stats.rx_packets;
524 }
525 }
526 }
527 yp->rx_len = 0;
528 yp->rx_crcl = 0x21;
529 yp->rx_crch = 0xf3;
530 }
531
532 static inline void yam_rx_byte(struct net_device *dev, struct yam_port *yp, unsigned char rxb)
533 {
534 if (yp->rx_len < YAM_MAX_FRAME) {
535 unsigned char c = yp->rx_crcl;
536 yp->rx_crcl = (chktabl[c] ^ yp->rx_crch);
537 yp->rx_crch = (chktabh[c] ^ rxb);
538 yp->rx_buf[yp->rx_len++] = rxb;
539 }
540 }
541
542 /********************************************************************************
543 * TX Section
544 ********************************************************************************/
545
546 static void ptt_on(struct net_device *dev)
547 {
548 outb(PTT_ON, MCR(dev->base_addr));
549 }
550
551 static void ptt_off(struct net_device *dev)
552 {
553 outb(PTT_OFF, MCR(dev->base_addr));
554 }
555
556 static int yam_send_packet(struct sk_buff *skb, struct net_device *dev)
557 {
558 struct yam_port *yp = netdev_priv(dev);
559
560 skb_queue_tail(&yp->send_queue, skb);
561 dev->trans_start = jiffies;
562 return 0;
563 }
564
565 static void yam_start_tx(struct net_device *dev, struct yam_port *yp)
566 {
567 if ((yp->tx_state == TX_TAIL) || (yp->txd == 0))
568 yp->tx_count = 1;
569 else
570 yp->tx_count = (yp->bitrate * yp->txd) / 8000;
571 yp->tx_state = TX_HEAD;
572 ptt_on(dev);
573 }
574
575 static unsigned short random_seed;
576
577 static inline unsigned short random_num(void)
578 {
579 random_seed = 28629 * random_seed + 157;
580 return random_seed;
581 }
582
583 static void yam_arbitrate(struct net_device *dev)
584 {
585 struct yam_port *yp = netdev_priv(dev);
586
587 if (yp->magic != YAM_MAGIC || yp->tx_state != TX_OFF ||
588 skb_queue_empty(&yp->send_queue))
589 return;
590 /* tx_state is TX_OFF and there is data to send */
591
592 if (yp->dupmode) {
593 /* Full duplex mode, don't wait */
594 yam_start_tx(dev, yp);
595 return;
596 }
597 if (yp->dcd) {
598 /* DCD on, wait slotime ... */
599 yp->slotcnt = yp->slot / 10;
600 return;
601 }
602 /* Is slottime passed ? */
603 if ((--yp->slotcnt) > 0)
604 return;
605
606 yp->slotcnt = yp->slot / 10;
607
608 /* is random > persist ? */
609 if ((random_num() % 256) > yp->pers)
610 return;
611
612 yam_start_tx(dev, yp);
613 }
614
615 static void yam_dotimer(unsigned long dummy)
616 {
617 int i;
618
619 for (i = 0; i < NR_PORTS; i++) {
620 struct net_device *dev = yam_devs[i];
621 if (dev && netif_running(dev))
622 yam_arbitrate(dev);
623 }
624 yam_timer.expires = jiffies + HZ / 100;
625 add_timer(&yam_timer);
626 }
627
628 static void yam_tx_byte(struct net_device *dev, struct yam_port *yp)
629 {
630 struct sk_buff *skb;
631 unsigned char b, temp;
632
633 switch (yp->tx_state) {
634 case TX_OFF:
635 break;
636 case TX_HEAD:
637 if (--yp->tx_count <= 0) {
638 if (!(skb = skb_dequeue(&yp->send_queue))) {
639 ptt_off(dev);
640 yp->tx_state = TX_OFF;
641 break;
642 }
643 yp->tx_state = TX_DATA;
644 if (skb->data[0] != 0) {
645 /* do_kiss_params(s, skb->data, skb->len); */
646 dev_kfree_skb_any(skb);
647 break;
648 }
649 yp->tx_len = skb->len - 1; /* strip KISS byte */
650 if (yp->tx_len >= YAM_MAX_FRAME || yp->tx_len < 2) {
651 dev_kfree_skb_any(skb);
652 break;
653 }
654 memcpy(yp->tx_buf, skb->data + 1, yp->tx_len);
655 dev_kfree_skb_any(skb);
656 yp->tx_count = 0;
657 yp->tx_crcl = 0x21;
658 yp->tx_crch = 0xf3;
659 yp->tx_state = TX_DATA;
660 }
661 break;
662 case TX_DATA:
663 b = yp->tx_buf[yp->tx_count++];
664 outb(b, THR(dev->base_addr));
665 temp = yp->tx_crcl;
666 yp->tx_crcl = chktabl[temp] ^ yp->tx_crch;
667 yp->tx_crch = chktabh[temp] ^ b;
668 if (yp->tx_count >= yp->tx_len) {
669 yp->tx_state = TX_CRC1;
670 }
671 break;
672 case TX_CRC1:
673 yp->tx_crch = chktabl[yp->tx_crcl] ^ yp->tx_crch;
674 yp->tx_crcl = chktabh[yp->tx_crcl] ^ chktabl[yp->tx_crch] ^ 0xff;
675 outb(yp->tx_crcl, THR(dev->base_addr));
676 yp->tx_state = TX_CRC2;
677 break;
678 case TX_CRC2:
679 outb(chktabh[yp->tx_crch] ^ 0xFF, THR(dev->base_addr));
680 if (skb_queue_empty(&yp->send_queue)) {
681 yp->tx_count = (yp->bitrate * yp->txtail) / 8000;
682 if (yp->dupmode == 2)
683 yp->tx_count += (yp->bitrate * yp->holdd) / 8;
684 if (yp->tx_count == 0)
685 yp->tx_count = 1;
686 yp->tx_state = TX_TAIL;
687 } else {
688 yp->tx_count = 1;
689 yp->tx_state = TX_HEAD;
690 }
691 ++yp->stats.tx_packets;
692 break;
693 case TX_TAIL:
694 if (--yp->tx_count <= 0) {
695 yp->tx_state = TX_OFF;
696 ptt_off(dev);
697 }
698 break;
699 }
700 }
701
702 /***********************************************************************************
703 * ISR routine
704 ************************************************************************************/
705
706 static irqreturn_t yam_interrupt(int irq, void *dev_id, struct pt_regs *regs)
707 {
708 struct net_device *dev;
709 struct yam_port *yp;
710 unsigned char iir;
711 int counter = 100;
712 int i;
713 int handled = 0;
714
715 for (i = 0; i < NR_PORTS; i++) {
716 dev = yam_devs[i];
717 yp = netdev_priv(dev);
718
719 if (!netif_running(dev))
720 continue;
721
722 while ((iir = IIR_MASK & inb(IIR(dev->base_addr))) != IIR_NOPEND) {
723 unsigned char msr = inb(MSR(dev->base_addr));
724 unsigned char lsr = inb(LSR(dev->base_addr));
725 unsigned char rxb;
726
727 handled = 1;
728
729 if (lsr & LSR_OE)
730 ++yp->stats.rx_fifo_errors;
731
732 yp->dcd = (msr & RX_DCD) ? 1 : 0;
733
734 if (--counter <= 0) {
735 printk(KERN_ERR "%s: too many irq iir=%d\n",
736 dev->name, iir);
737 goto out;
738 }
739 if (msr & TX_RDY) {
740 ++yp->nb_mdint;
741 yam_tx_byte(dev, yp);
742 }
743 if (lsr & LSR_RXC) {
744 ++yp->nb_rxint;
745 rxb = inb(RBR(dev->base_addr));
746 if (msr & RX_FLAG)
747 yam_rx_flag(dev, yp);
748 else
749 yam_rx_byte(dev, yp, rxb);
750 }
751 }
752 }
753 out:
754 return IRQ_RETVAL(handled);
755 }
756
757 #ifdef CONFIG_PROC_FS
758
759 static void *yam_seq_start(struct seq_file *seq, loff_t *pos)
760 {
761 return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
762 }
763
764 static void *yam_seq_next(struct seq_file *seq, void *v, loff_t *pos)
765 {
766 ++*pos;
767 return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
768 }
769
770 static void yam_seq_stop(struct seq_file *seq, void *v)
771 {
772 }
773
774 static int yam_seq_show(struct seq_file *seq, void *v)
775 {
776 struct net_device *dev = v;
777 const struct yam_port *yp = netdev_priv(dev);
778
779 seq_printf(seq, "Device %s\n", dev->name);
780 seq_printf(seq, " Up %d\n", netif_running(dev));
781 seq_printf(seq, " Speed %u\n", yp->bitrate);
782 seq_printf(seq, " IoBase 0x%x\n", yp->iobase);
783 seq_printf(seq, " BaudRate %u\n", yp->baudrate);
784 seq_printf(seq, " IRQ %u\n", yp->irq);
785 seq_printf(seq, " TxState %u\n", yp->tx_state);
786 seq_printf(seq, " Duplex %u\n", yp->dupmode);
787 seq_printf(seq, " HoldDly %u\n", yp->holdd);
788 seq_printf(seq, " TxDelay %u\n", yp->txd);
789 seq_printf(seq, " TxTail %u\n", yp->txtail);
790 seq_printf(seq, " SlotTime %u\n", yp->slot);
791 seq_printf(seq, " Persist %u\n", yp->pers);
792 seq_printf(seq, " TxFrames %lu\n", yp->stats.tx_packets);
793 seq_printf(seq, " RxFrames %lu\n", yp->stats.rx_packets);
794 seq_printf(seq, " TxInt %u\n", yp->nb_mdint);
795 seq_printf(seq, " RxInt %u\n", yp->nb_rxint);
796 seq_printf(seq, " RxOver %lu\n", yp->stats.rx_fifo_errors);
797 seq_printf(seq, "\n");
798 return 0;
799 }
800
801 static struct seq_operations yam_seqops = {
802 .start = yam_seq_start,
803 .next = yam_seq_next,
804 .stop = yam_seq_stop,
805 .show = yam_seq_show,
806 };
807
808 static int yam_info_open(struct inode *inode, struct file *file)
809 {
810 return seq_open(file, &yam_seqops);
811 }
812
813 static struct file_operations yam_info_fops = {
814 .owner = THIS_MODULE,
815 .open = yam_info_open,
816 .read = seq_read,
817 .llseek = seq_lseek,
818 .release = seq_release,
819 };
820
821 #endif
822
823
824 /* --------------------------------------------------------------------- */
825
826 static struct net_device_stats *yam_get_stats(struct net_device *dev)
827 {
828 struct yam_port *yp;
829
830 if (!dev)
831 return NULL;
832
833 yp = netdev_priv(dev);
834 if (yp->magic != YAM_MAGIC)
835 return NULL;
836
837 /*
838 * Get the current statistics. This may be called with the
839 * card open or closed.
840 */
841 return &yp->stats;
842 }
843
844 /* --------------------------------------------------------------------- */
845
846 static int yam_open(struct net_device *dev)
847 {
848 struct yam_port *yp = netdev_priv(dev);
849 enum uart u;
850 int i;
851 int ret=0;
852
853 printk(KERN_INFO "Trying %s at iobase 0x%lx irq %u\n", dev->name, dev->base_addr, dev->irq);
854
855 if (!dev || !yp->bitrate)
856 return -ENXIO;
857 if (!dev->base_addr || dev->base_addr > 0x1000 - YAM_EXTENT ||
858 dev->irq < 2 || dev->irq > 15) {
859 return -ENXIO;
860 }
861 if (!request_region(dev->base_addr, YAM_EXTENT, dev->name))
862 {
863 printk(KERN_ERR "%s: cannot 0x%lx busy\n", dev->name, dev->base_addr);
864 return -EACCES;
865 }
866 if ((u = yam_check_uart(dev->base_addr)) == c_uart_unknown) {
867 printk(KERN_ERR "%s: cannot find uart type\n", dev->name);
868 ret = -EIO;
869 goto out_release_base;
870 }
871 if (fpga_download(dev->base_addr, yp->bitrate)) {
872 printk(KERN_ERR "%s: cannot init FPGA\n", dev->name);
873 ret = -EIO;
874 goto out_release_base;
875 }
876 outb(0, IER(dev->base_addr));
877 if (request_irq(dev->irq, yam_interrupt, SA_INTERRUPT | SA_SHIRQ, dev->name, dev)) {
878 printk(KERN_ERR "%s: irq %d busy\n", dev->name, dev->irq);
879 ret = -EBUSY;
880 goto out_release_base;
881 }
882
883 yam_set_uart(dev);
884
885 netif_start_queue(dev);
886
887 yp->slotcnt = yp->slot / 10;
888
889 /* Reset overruns for all ports - FPGA programming makes overruns */
890 for (i = 0; i < NR_PORTS; i++) {
891 struct net_device *dev = yam_devs[i];
892 struct yam_port *yp = netdev_priv(dev);
893 inb(LSR(dev->base_addr));
894 yp->stats.rx_fifo_errors = 0;
895 }
896
897 printk(KERN_INFO "%s at iobase 0x%lx irq %u uart %s\n", dev->name, dev->base_addr, dev->irq,
898 uart_str[u]);
899 return 0;
900
901 out_release_base:
902 release_region(dev->base_addr, YAM_EXTENT);
903 return ret;
904 }
905
906 /* --------------------------------------------------------------------- */
907
908 static int yam_close(struct net_device *dev)
909 {
910 struct sk_buff *skb;
911 struct yam_port *yp = netdev_priv(dev);
912
913 if (!dev)
914 return -EINVAL;
915
916 /*
917 * disable interrupts
918 */
919 outb(0, IER(dev->base_addr));
920 outb(1, MCR(dev->base_addr));
921 /* Remove IRQ handler if last */
922 free_irq(dev->irq,dev);
923 release_region(dev->base_addr, YAM_EXTENT);
924 netif_stop_queue(dev);
925 while ((skb = skb_dequeue(&yp->send_queue)))
926 dev_kfree_skb(skb);
927
928 printk(KERN_INFO "%s: close yam at iobase 0x%lx irq %u\n",
929 yam_drvname, dev->base_addr, dev->irq);
930 return 0;
931 }
932
933 /* --------------------------------------------------------------------- */
934
935 static int yam_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
936 {
937 struct yam_port *yp = netdev_priv(dev);
938 struct yamdrv_ioctl_cfg yi;
939 struct yamdrv_ioctl_mcs *ym;
940 int ioctl_cmd;
941
942 if (copy_from_user(&ioctl_cmd, ifr->ifr_data, sizeof(int)))
943 return -EFAULT;
944
945 if (yp->magic != YAM_MAGIC)
946 return -EINVAL;
947
948 if (!capable(CAP_NET_ADMIN))
949 return -EPERM;
950
951 if (cmd != SIOCDEVPRIVATE)
952 return -EINVAL;
953
954 switch (ioctl_cmd) {
955
956 case SIOCYAMRESERVED:
957 return -EINVAL; /* unused */
958
959 case SIOCYAMSMCS:
960 if (netif_running(dev))
961 return -EINVAL; /* Cannot change this parameter when up */
962 if ((ym = kmalloc(sizeof(struct yamdrv_ioctl_mcs), GFP_KERNEL)) == NULL)
963 return -ENOBUFS;
964 ym->bitrate = 9600;
965 if (copy_from_user(ym, ifr->ifr_data, sizeof(struct yamdrv_ioctl_mcs))) {
966 kfree(ym);
967 return -EFAULT;
968 }
969 if (ym->bitrate > YAM_MAXBITRATE) {
970 kfree(ym);
971 return -EINVAL;
972 }
973 add_mcs(ym->bits, ym->bitrate);
974 kfree(ym);
975 break;
976
977 case SIOCYAMSCFG:
978 if (!capable(CAP_SYS_RAWIO))
979 return -EPERM;
980 if (copy_from_user(&yi, ifr->ifr_data, sizeof(struct yamdrv_ioctl_cfg)))
981 return -EFAULT;
982
983 if ((yi.cfg.mask & YAM_IOBASE) && netif_running(dev))
984 return -EINVAL; /* Cannot change this parameter when up */
985 if ((yi.cfg.mask & YAM_IRQ) && netif_running(dev))
986 return -EINVAL; /* Cannot change this parameter when up */
987 if ((yi.cfg.mask & YAM_BITRATE) && netif_running(dev))
988 return -EINVAL; /* Cannot change this parameter when up */
989 if ((yi.cfg.mask & YAM_BAUDRATE) && netif_running(dev))
990 return -EINVAL; /* Cannot change this parameter when up */
991
992 if (yi.cfg.mask & YAM_IOBASE) {
993 yp->iobase = yi.cfg.iobase;
994 dev->base_addr = yi.cfg.iobase;
995 }
996 if (yi.cfg.mask & YAM_IRQ) {
997 if (yi.cfg.irq > 15)
998 return -EINVAL;
999 yp->irq = yi.cfg.irq;
1000 dev->irq = yi.cfg.irq;
1001 }
1002 if (yi.cfg.mask & YAM_BITRATE) {
1003 if (yi.cfg.bitrate > YAM_MAXBITRATE)
1004 return -EINVAL;
1005 yp->bitrate = yi.cfg.bitrate;
1006 }
1007 if (yi.cfg.mask & YAM_BAUDRATE) {
1008 if (yi.cfg.baudrate > YAM_MAXBAUDRATE)
1009 return -EINVAL;
1010 yp->baudrate = yi.cfg.baudrate;
1011 }
1012 if (yi.cfg.mask & YAM_MODE) {
1013 if (yi.cfg.mode > YAM_MAXMODE)
1014 return -EINVAL;
1015 yp->dupmode = yi.cfg.mode;
1016 }
1017 if (yi.cfg.mask & YAM_HOLDDLY) {
1018 if (yi.cfg.holddly > YAM_MAXHOLDDLY)
1019 return -EINVAL;
1020 yp->holdd = yi.cfg.holddly;
1021 }
1022 if (yi.cfg.mask & YAM_TXDELAY) {
1023 if (yi.cfg.txdelay > YAM_MAXTXDELAY)
1024 return -EINVAL;
1025 yp->txd = yi.cfg.txdelay;
1026 }
1027 if (yi.cfg.mask & YAM_TXTAIL) {
1028 if (yi.cfg.txtail > YAM_MAXTXTAIL)
1029 return -EINVAL;
1030 yp->txtail = yi.cfg.txtail;
1031 }
1032 if (yi.cfg.mask & YAM_PERSIST) {
1033 if (yi.cfg.persist > YAM_MAXPERSIST)
1034 return -EINVAL;
1035 yp->pers = yi.cfg.persist;
1036 }
1037 if (yi.cfg.mask & YAM_SLOTTIME) {
1038 if (yi.cfg.slottime > YAM_MAXSLOTTIME)
1039 return -EINVAL;
1040 yp->slot = yi.cfg.slottime;
1041 yp->slotcnt = yp->slot / 10;
1042 }
1043 break;
1044
1045 case SIOCYAMGCFG:
1046 yi.cfg.mask = 0xffffffff;
1047 yi.cfg.iobase = yp->iobase;
1048 yi.cfg.irq = yp->irq;
1049 yi.cfg.bitrate = yp->bitrate;
1050 yi.cfg.baudrate = yp->baudrate;
1051 yi.cfg.mode = yp->dupmode;
1052 yi.cfg.txdelay = yp->txd;
1053 yi.cfg.holddly = yp->holdd;
1054 yi.cfg.txtail = yp->txtail;
1055 yi.cfg.persist = yp->pers;
1056 yi.cfg.slottime = yp->slot;
1057 if (copy_to_user(ifr->ifr_data, &yi, sizeof(struct yamdrv_ioctl_cfg)))
1058 return -EFAULT;
1059 break;
1060
1061 default:
1062 return -EINVAL;
1063
1064 }
1065
1066 return 0;
1067 }
1068
1069 /* --------------------------------------------------------------------- */
1070
1071 static int yam_set_mac_address(struct net_device *dev, void *addr)
1072 {
1073 struct sockaddr *sa = (struct sockaddr *) addr;
1074
1075 /* addr is an AX.25 shifted ASCII mac address */
1076 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
1077 return 0;
1078 }
1079
1080 /* --------------------------------------------------------------------- */
1081
1082 static void yam_setup(struct net_device *dev)
1083 {
1084 struct yam_port *yp = netdev_priv(dev);
1085
1086 yp->magic = YAM_MAGIC;
1087 yp->bitrate = DEFAULT_BITRATE;
1088 yp->baudrate = DEFAULT_BITRATE * 2;
1089 yp->iobase = 0;
1090 yp->irq = 0;
1091 yp->dupmode = 0;
1092 yp->holdd = DEFAULT_HOLDD;
1093 yp->txd = DEFAULT_TXD;
1094 yp->txtail = DEFAULT_TXTAIL;
1095 yp->slot = DEFAULT_SLOT;
1096 yp->pers = DEFAULT_PERS;
1097 yp->dev = dev;
1098
1099 dev->base_addr = yp->iobase;
1100 dev->irq = yp->irq;
1101
1102 dev->open = yam_open;
1103 dev->stop = yam_close;
1104 dev->do_ioctl = yam_ioctl;
1105 dev->hard_start_xmit = yam_send_packet;
1106 dev->get_stats = yam_get_stats;
1107
1108 skb_queue_head_init(&yp->send_queue);
1109
1110 dev->hard_header = ax25_hard_header;
1111 dev->rebuild_header = ax25_rebuild_header;
1112
1113 dev->set_mac_address = yam_set_mac_address;
1114
1115 dev->type = ARPHRD_AX25;
1116 dev->hard_header_len = AX25_MAX_HEADER_LEN;
1117 dev->mtu = AX25_MTU;
1118 dev->addr_len = AX25_ADDR_LEN;
1119 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
1120 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
1121 }
1122
1123 static int __init yam_init_driver(void)
1124 {
1125 struct net_device *dev;
1126 int i, err;
1127 char name[IFNAMSIZ];
1128
1129 printk(yam_drvinfo);
1130
1131 for (i = 0; i < NR_PORTS; i++) {
1132 sprintf(name, "yam%d", i);
1133
1134 dev = alloc_netdev(sizeof(struct yam_port), name,
1135 yam_setup);
1136 if (!dev) {
1137 printk(KERN_ERR "yam: cannot allocate net device %s\n",
1138 dev->name);
1139 err = -ENOMEM;
1140 goto error;
1141 }
1142
1143 err = register_netdev(dev);
1144 if (err) {
1145 printk(KERN_WARNING "yam: cannot register net device %s\n", dev->name);
1146 goto error;
1147 }
1148 yam_devs[i] = dev;
1149
1150 }
1151
1152 yam_timer.function = yam_dotimer;
1153 yam_timer.expires = jiffies + HZ / 100;
1154 add_timer(&yam_timer);
1155
1156 proc_net_fops_create("yam", S_IRUGO, &yam_info_fops);
1157 return 0;
1158 error:
1159 while (--i >= 0) {
1160 unregister_netdev(yam_devs[i]);
1161 free_netdev(yam_devs[i]);
1162 }
1163 return err;
1164 }
1165
1166 /* --------------------------------------------------------------------- */
1167
1168 static void __exit yam_cleanup_driver(void)
1169 {
1170 struct yam_mcs *p;
1171 int i;
1172
1173 del_timer(&yam_timer);
1174 for (i = 0; i < NR_PORTS; i++) {
1175 struct net_device *dev = yam_devs[i];
1176 if (dev) {
1177 unregister_netdev(dev);
1178 free_netdev(dev);
1179 }
1180 }
1181
1182 while (yam_data) {
1183 p = yam_data;
1184 yam_data = yam_data->next;
1185 kfree(p);
1186 }
1187
1188 proc_net_remove("yam");
1189 }
1190
1191 /* --------------------------------------------------------------------- */
1192
1193 MODULE_AUTHOR("Frederic Rible F1OAT frible@teaser.fr");
1194 MODULE_DESCRIPTION("Yam amateur radio modem driver");
1195 MODULE_LICENSE("GPL");
1196
1197 module_init(yam_init_driver);
1198 module_exit(yam_cleanup_driver);
1199
1200 /* --------------------------------------------------------------------- */
1201
Linux with added FPC-III support