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