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