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