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