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