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