xref: /openbmc/linux/drivers/net/hamradio/yam.c (revision 31b90347)
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 Persistence
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 <linux/interrupt.h>
56 #include <linux/ioport.h>
57 #include <linux/firmware.h>
58 #include <linux/platform_device.h>
59 
60 #include <linux/netdevice.h>
61 #include <linux/if_arp.h>
62 #include <linux/etherdevice.h>
63 #include <linux/skbuff.h>
64 #include <net/ax25.h>
65 
66 #include <linux/kernel.h>
67 #include <linux/proc_fs.h>
68 #include <linux/seq_file.h>
69 #include <net/net_namespace.h>
70 
71 #include <asm/uaccess.h>
72 #include <linux/init.h>
73 
74 #include <linux/yam.h>
75 
76 /* --------------------------------------------------------------------- */
77 
78 static const char yam_drvname[] = "yam";
79 static const char yam_drvinfo[] __initconst = KERN_INFO \
80 	"YAM driver version 0.8 by F1OAT/F6FBB\n";
81 
82 /* --------------------------------------------------------------------- */
83 
84 #define FIRMWARE_9600	"yam/9600.bin"
85 #define FIRMWARE_1200	"yam/1200.bin"
86 
87 #define YAM_9600	1
88 #define YAM_1200	2
89 
90 #define NR_PORTS	4
91 #define YAM_MAGIC	0xF10A7654
92 
93 /* Transmitter states */
94 
95 #define TX_OFF		0
96 #define TX_HEAD		1
97 #define TX_DATA		2
98 #define TX_CRC1		3
99 #define TX_CRC2		4
100 #define TX_TAIL		5
101 
102 #define YAM_MAX_FRAME	1024
103 
104 #define DEFAULT_BITRATE	9600			/* bps */
105 #define DEFAULT_HOLDD	10			/* sec */
106 #define DEFAULT_TXD	300			/* ms */
107 #define DEFAULT_TXTAIL	10			/* ms */
108 #define DEFAULT_SLOT	100			/* ms */
109 #define DEFAULT_PERS	64			/* 0->255 */
110 
111 struct yam_port {
112 	int magic;
113 	int bitrate;
114 	int baudrate;
115 	int iobase;
116 	int irq;
117 	int dupmode;
118 
119 	struct net_device *dev;
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 /*
348  * predef should be 0 for loading user defined mcs
349  * predef should be YAM_1200 for loading predef 1200 mcs
350  * predef should be YAM_9600 for loading predef 9600 mcs
351  */
352 static unsigned char *add_mcs(unsigned char *bits, int bitrate,
353 			      unsigned int predef)
354 {
355 	const char *fw_name[2] = {FIRMWARE_9600, FIRMWARE_1200};
356 	const struct firmware *fw;
357 	struct platform_device *pdev;
358 	struct yam_mcs *p;
359 	int err;
360 
361 	switch (predef) {
362 	case 0:
363 		fw = NULL;
364 		break;
365 	case YAM_1200:
366 	case YAM_9600:
367 		predef--;
368 		pdev = platform_device_register_simple("yam", 0, NULL, 0);
369 		if (IS_ERR(pdev)) {
370 			printk(KERN_ERR "yam: Failed to register firmware\n");
371 			return NULL;
372 		}
373 		err = request_firmware(&fw, fw_name[predef], &pdev->dev);
374 		platform_device_unregister(pdev);
375 		if (err) {
376 			printk(KERN_ERR "Failed to load firmware \"%s\"\n",
377 			       fw_name[predef]);
378 			return NULL;
379 		}
380 		if (fw->size != YAM_FPGA_SIZE) {
381 			printk(KERN_ERR "Bogus length %zu in firmware \"%s\"\n",
382 			       fw->size, fw_name[predef]);
383 			release_firmware(fw);
384 			return NULL;
385 		}
386 		bits = (unsigned char *)fw->data;
387 		break;
388 	default:
389 		printk(KERN_ERR "yam: Invalid predef number %u\n", predef);
390 		return NULL;
391 	}
392 
393 	/* If it already exists, replace the bit data */
394 	p = yam_data;
395 	while (p) {
396 		if (p->bitrate == bitrate) {
397 			memcpy(p->bits, bits, YAM_FPGA_SIZE);
398 			goto out;
399 		}
400 		p = p->next;
401 	}
402 
403 	/* Allocate a new mcs */
404 	if ((p = kmalloc(sizeof(struct yam_mcs), GFP_KERNEL)) == NULL) {
405 		release_firmware(fw);
406 		return NULL;
407 	}
408 	memcpy(p->bits, bits, YAM_FPGA_SIZE);
409 	p->bitrate = bitrate;
410 	p->next = yam_data;
411 	yam_data = p;
412  out:
413 	release_firmware(fw);
414 	return p->bits;
415 }
416 
417 static unsigned char *get_mcs(int bitrate)
418 {
419 	struct yam_mcs *p;
420 
421 	p = yam_data;
422 	while (p) {
423 		if (p->bitrate == bitrate)
424 			return p->bits;
425 		p = p->next;
426 	}
427 
428 	/* Load predefined mcs data */
429 	switch (bitrate) {
430 	case 1200:
431 		/* setting predef as YAM_1200 for loading predef 1200 mcs */
432 		return add_mcs(NULL, bitrate, YAM_1200);
433 	default:
434 		/* setting predef as YAM_9600 for loading predef 9600 mcs */
435 		return add_mcs(NULL, bitrate, YAM_9600);
436 	}
437 }
438 
439 /*
440  * download bitstream to FPGA
441  * data is contained in bits[] array in yam1200.h resp. yam9600.h
442  */
443 
444 static int fpga_download(int iobase, int bitrate)
445 {
446 	int i, rc;
447 	unsigned char *pbits;
448 
449 	pbits = get_mcs(bitrate);
450 	if (pbits == NULL)
451 		return -1;
452 
453 	fpga_reset(iobase);
454 	for (i = 0; i < YAM_FPGA_SIZE; i++) {
455 		if (fpga_write(iobase, pbits[i])) {
456 			printk(KERN_ERR "yam: error in write cycle\n");
457 			return -1;			/* write... */
458 		}
459 	}
460 
461 	fpga_write(iobase, 0xFF);
462 	rc = inb(MSR(iobase));		/* check DONE signal */
463 
464 	/* Needed for some hardwares */
465 	delay(50);
466 
467 	return (rc & MSR_DSR) ? 0 : -1;
468 }
469 
470 
471 /************************************************************************
472 * Serial port init
473 ************************************************************************/
474 
475 static void yam_set_uart(struct net_device *dev)
476 {
477 	struct yam_port *yp = netdev_priv(dev);
478 	int divisor = 115200 / yp->baudrate;
479 
480 	outb(0, IER(dev->base_addr));
481 	outb(LCR_DLAB | LCR_BIT8, LCR(dev->base_addr));
482 	outb(divisor, DLL(dev->base_addr));
483 	outb(0, DLM(dev->base_addr));
484 	outb(LCR_BIT8, LCR(dev->base_addr));
485 	outb(PTT_OFF, MCR(dev->base_addr));
486 	outb(0x00, FCR(dev->base_addr));
487 
488 	/* Flush pending irq */
489 
490 	inb(RBR(dev->base_addr));
491 	inb(MSR(dev->base_addr));
492 
493 	/* Enable rx irq */
494 
495 	outb(ENABLE_RTXINT, IER(dev->base_addr));
496 }
497 
498 
499 /* --------------------------------------------------------------------- */
500 
501 enum uart {
502 	c_uart_unknown, c_uart_8250,
503 	c_uart_16450, c_uart_16550, c_uart_16550A
504 };
505 
506 static const char *uart_str[] =
507 {"unknown", "8250", "16450", "16550", "16550A"};
508 
509 static enum uart yam_check_uart(unsigned int iobase)
510 {
511 	unsigned char b1, b2, b3;
512 	enum uart u;
513 	enum uart uart_tab[] =
514 	{c_uart_16450, c_uart_unknown, c_uart_16550, c_uart_16550A};
515 
516 	b1 = inb(MCR(iobase));
517 	outb(b1 | 0x10, MCR(iobase));	/* loopback mode */
518 	b2 = inb(MSR(iobase));
519 	outb(0x1a, MCR(iobase));
520 	b3 = inb(MSR(iobase)) & 0xf0;
521 	outb(b1, MCR(iobase));		/* restore old values */
522 	outb(b2, MSR(iobase));
523 	if (b3 != 0x90)
524 		return c_uart_unknown;
525 	inb(RBR(iobase));
526 	inb(RBR(iobase));
527 	outb(0x01, FCR(iobase));	/* enable FIFOs */
528 	u = uart_tab[(inb(IIR(iobase)) >> 6) & 3];
529 	if (u == c_uart_16450) {
530 		outb(0x5a, SCR(iobase));
531 		b1 = inb(SCR(iobase));
532 		outb(0xa5, SCR(iobase));
533 		b2 = inb(SCR(iobase));
534 		if ((b1 != 0x5a) || (b2 != 0xa5))
535 			u = c_uart_8250;
536 	}
537 	return u;
538 }
539 
540 /******************************************************************************
541 * Rx Section
542 ******************************************************************************/
543 static inline void yam_rx_flag(struct net_device *dev, struct yam_port *yp)
544 {
545 	if (yp->dcd && yp->rx_len >= 3 && yp->rx_len < YAM_MAX_FRAME) {
546 		int pkt_len = yp->rx_len - 2 + 1;	/* -CRC + kiss */
547 		struct sk_buff *skb;
548 
549 		if ((yp->rx_crch & yp->rx_crcl) != 0xFF) {
550 			/* Bad crc */
551 		} else {
552 			if (!(skb = dev_alloc_skb(pkt_len))) {
553 				printk(KERN_WARNING "%s: memory squeeze, dropping packet\n", dev->name);
554 				++dev->stats.rx_dropped;
555 			} else {
556 				unsigned char *cp;
557 				cp = skb_put(skb, pkt_len);
558 				*cp++ = 0;		/* KISS kludge */
559 				memcpy(cp, yp->rx_buf, pkt_len - 1);
560 				skb->protocol = ax25_type_trans(skb, dev);
561 				netif_rx(skb);
562 				++dev->stats.rx_packets;
563 			}
564 		}
565 	}
566 	yp->rx_len = 0;
567 	yp->rx_crcl = 0x21;
568 	yp->rx_crch = 0xf3;
569 }
570 
571 static inline void yam_rx_byte(struct net_device *dev, struct yam_port *yp, unsigned char rxb)
572 {
573 	if (yp->rx_len < YAM_MAX_FRAME) {
574 		unsigned char c = yp->rx_crcl;
575 		yp->rx_crcl = (chktabl[c] ^ yp->rx_crch);
576 		yp->rx_crch = (chktabh[c] ^ rxb);
577 		yp->rx_buf[yp->rx_len++] = rxb;
578 	}
579 }
580 
581 /********************************************************************************
582 * TX Section
583 ********************************************************************************/
584 
585 static void ptt_on(struct net_device *dev)
586 {
587 	outb(PTT_ON, MCR(dev->base_addr));
588 }
589 
590 static void ptt_off(struct net_device *dev)
591 {
592 	outb(PTT_OFF, MCR(dev->base_addr));
593 }
594 
595 static netdev_tx_t yam_send_packet(struct sk_buff *skb,
596 					 struct net_device *dev)
597 {
598 	struct yam_port *yp = netdev_priv(dev);
599 
600 	skb_queue_tail(&yp->send_queue, skb);
601 	dev->trans_start = jiffies;
602 	return NETDEV_TX_OK;
603 }
604 
605 static void yam_start_tx(struct net_device *dev, struct yam_port *yp)
606 {
607 	if ((yp->tx_state == TX_TAIL) || (yp->txd == 0))
608 		yp->tx_count = 1;
609 	else
610 		yp->tx_count = (yp->bitrate * yp->txd) / 8000;
611 	yp->tx_state = TX_HEAD;
612 	ptt_on(dev);
613 }
614 
615 static void yam_arbitrate(struct net_device *dev)
616 {
617 	struct yam_port *yp = netdev_priv(dev);
618 
619 	if (yp->magic != YAM_MAGIC || yp->tx_state != TX_OFF ||
620 	    skb_queue_empty(&yp->send_queue))
621 		return;
622 	/* tx_state is TX_OFF and there is data to send */
623 
624 	if (yp->dupmode) {
625 		/* Full duplex mode, don't wait */
626 		yam_start_tx(dev, yp);
627 		return;
628 	}
629 	if (yp->dcd) {
630 		/* DCD on, wait slotime ... */
631 		yp->slotcnt = yp->slot / 10;
632 		return;
633 	}
634 	/* Is slottime passed ? */
635 	if ((--yp->slotcnt) > 0)
636 		return;
637 
638 	yp->slotcnt = yp->slot / 10;
639 
640 	/* is random > persist ? */
641 	if ((prandom_u32() % 256) > yp->pers)
642 		return;
643 
644 	yam_start_tx(dev, yp);
645 }
646 
647 static void yam_dotimer(unsigned long dummy)
648 {
649 	int i;
650 
651 	for (i = 0; i < NR_PORTS; i++) {
652 		struct net_device *dev = yam_devs[i];
653 		if (dev && netif_running(dev))
654 			yam_arbitrate(dev);
655 	}
656 	yam_timer.expires = jiffies + HZ / 100;
657 	add_timer(&yam_timer);
658 }
659 
660 static void yam_tx_byte(struct net_device *dev, struct yam_port *yp)
661 {
662 	struct sk_buff *skb;
663 	unsigned char b, temp;
664 
665 	switch (yp->tx_state) {
666 	case TX_OFF:
667 		break;
668 	case TX_HEAD:
669 		if (--yp->tx_count <= 0) {
670 			if (!(skb = skb_dequeue(&yp->send_queue))) {
671 				ptt_off(dev);
672 				yp->tx_state = TX_OFF;
673 				break;
674 			}
675 			yp->tx_state = TX_DATA;
676 			if (skb->data[0] != 0) {
677 /*                              do_kiss_params(s, skb->data, skb->len); */
678 				dev_kfree_skb_any(skb);
679 				break;
680 			}
681 			yp->tx_len = skb->len - 1;	/* strip KISS byte */
682 			if (yp->tx_len >= YAM_MAX_FRAME || yp->tx_len < 2) {
683         			dev_kfree_skb_any(skb);
684 				break;
685 			}
686 			skb_copy_from_linear_data_offset(skb, 1,
687 							 yp->tx_buf,
688 							 yp->tx_len);
689 			dev_kfree_skb_any(skb);
690 			yp->tx_count = 0;
691 			yp->tx_crcl = 0x21;
692 			yp->tx_crch = 0xf3;
693 			yp->tx_state = TX_DATA;
694 		}
695 		break;
696 	case TX_DATA:
697 		b = yp->tx_buf[yp->tx_count++];
698 		outb(b, THR(dev->base_addr));
699 		temp = yp->tx_crcl;
700 		yp->tx_crcl = chktabl[temp] ^ yp->tx_crch;
701 		yp->tx_crch = chktabh[temp] ^ b;
702 		if (yp->tx_count >= yp->tx_len) {
703 			yp->tx_state = TX_CRC1;
704 		}
705 		break;
706 	case TX_CRC1:
707 		yp->tx_crch = chktabl[yp->tx_crcl] ^ yp->tx_crch;
708 		yp->tx_crcl = chktabh[yp->tx_crcl] ^ chktabl[yp->tx_crch] ^ 0xff;
709 		outb(yp->tx_crcl, THR(dev->base_addr));
710 		yp->tx_state = TX_CRC2;
711 		break;
712 	case TX_CRC2:
713 		outb(chktabh[yp->tx_crch] ^ 0xFF, THR(dev->base_addr));
714 		if (skb_queue_empty(&yp->send_queue)) {
715 			yp->tx_count = (yp->bitrate * yp->txtail) / 8000;
716 			if (yp->dupmode == 2)
717 				yp->tx_count += (yp->bitrate * yp->holdd) / 8;
718 			if (yp->tx_count == 0)
719 				yp->tx_count = 1;
720 			yp->tx_state = TX_TAIL;
721 		} else {
722 			yp->tx_count = 1;
723 			yp->tx_state = TX_HEAD;
724 		}
725 		++dev->stats.tx_packets;
726 		break;
727 	case TX_TAIL:
728 		if (--yp->tx_count <= 0) {
729 			yp->tx_state = TX_OFF;
730 			ptt_off(dev);
731 		}
732 		break;
733 	}
734 }
735 
736 /***********************************************************************************
737 * ISR routine
738 ************************************************************************************/
739 
740 static irqreturn_t yam_interrupt(int irq, void *dev_id)
741 {
742 	struct net_device *dev;
743 	struct yam_port *yp;
744 	unsigned char iir;
745 	int counter = 100;
746 	int i;
747 	int handled = 0;
748 
749 	for (i = 0; i < NR_PORTS; i++) {
750 		dev = yam_devs[i];
751 		yp = netdev_priv(dev);
752 
753 		if (!netif_running(dev))
754 			continue;
755 
756 		while ((iir = IIR_MASK & inb(IIR(dev->base_addr))) != IIR_NOPEND) {
757 			unsigned char msr = inb(MSR(dev->base_addr));
758 			unsigned char lsr = inb(LSR(dev->base_addr));
759 			unsigned char rxb;
760 
761 			handled = 1;
762 
763 			if (lsr & LSR_OE)
764 				++dev->stats.rx_fifo_errors;
765 
766 			yp->dcd = (msr & RX_DCD) ? 1 : 0;
767 
768 			if (--counter <= 0) {
769 				printk(KERN_ERR "%s: too many irq iir=%d\n",
770 						dev->name, iir);
771 				goto out;
772 			}
773 			if (msr & TX_RDY) {
774 				++yp->nb_mdint;
775 				yam_tx_byte(dev, yp);
776 			}
777 			if (lsr & LSR_RXC) {
778 				++yp->nb_rxint;
779 				rxb = inb(RBR(dev->base_addr));
780 				if (msr & RX_FLAG)
781 					yam_rx_flag(dev, yp);
782 				else
783 					yam_rx_byte(dev, yp, rxb);
784 			}
785 		}
786 	}
787 out:
788 	return IRQ_RETVAL(handled);
789 }
790 
791 #ifdef CONFIG_PROC_FS
792 
793 static void *yam_seq_start(struct seq_file *seq, loff_t *pos)
794 {
795 	return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
796 }
797 
798 static void *yam_seq_next(struct seq_file *seq, void *v, loff_t *pos)
799 {
800 	++*pos;
801 	return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
802 }
803 
804 static void yam_seq_stop(struct seq_file *seq, void *v)
805 {
806 }
807 
808 static int yam_seq_show(struct seq_file *seq, void *v)
809 {
810 	struct net_device *dev = v;
811 	const struct yam_port *yp = netdev_priv(dev);
812 
813 	seq_printf(seq, "Device %s\n", dev->name);
814 	seq_printf(seq, "  Up       %d\n", netif_running(dev));
815 	seq_printf(seq, "  Speed    %u\n", yp->bitrate);
816 	seq_printf(seq, "  IoBase   0x%x\n", yp->iobase);
817 	seq_printf(seq, "  BaudRate %u\n", yp->baudrate);
818 	seq_printf(seq, "  IRQ      %u\n", yp->irq);
819 	seq_printf(seq, "  TxState  %u\n", yp->tx_state);
820 	seq_printf(seq, "  Duplex   %u\n", yp->dupmode);
821 	seq_printf(seq, "  HoldDly  %u\n", yp->holdd);
822 	seq_printf(seq, "  TxDelay  %u\n", yp->txd);
823 	seq_printf(seq, "  TxTail   %u\n", yp->txtail);
824 	seq_printf(seq, "  SlotTime %u\n", yp->slot);
825 	seq_printf(seq, "  Persist  %u\n", yp->pers);
826 	seq_printf(seq, "  TxFrames %lu\n", dev->stats.tx_packets);
827 	seq_printf(seq, "  RxFrames %lu\n", dev->stats.rx_packets);
828 	seq_printf(seq, "  TxInt    %u\n", yp->nb_mdint);
829 	seq_printf(seq, "  RxInt    %u\n", yp->nb_rxint);
830 	seq_printf(seq, "  RxOver   %lu\n", dev->stats.rx_fifo_errors);
831 	seq_printf(seq, "\n");
832 	return 0;
833 }
834 
835 static const struct seq_operations yam_seqops = {
836 	.start = yam_seq_start,
837 	.next = yam_seq_next,
838 	.stop = yam_seq_stop,
839 	.show = yam_seq_show,
840 };
841 
842 static int yam_info_open(struct inode *inode, struct file *file)
843 {
844 	return seq_open(file, &yam_seqops);
845 }
846 
847 static const struct file_operations yam_info_fops = {
848 	.owner = THIS_MODULE,
849 	.open = yam_info_open,
850 	.read = seq_read,
851 	.llseek = seq_lseek,
852 	.release = seq_release,
853 };
854 
855 #endif
856 
857 
858 /* --------------------------------------------------------------------- */
859 
860 static int yam_open(struct net_device *dev)
861 {
862 	struct yam_port *yp = netdev_priv(dev);
863 	enum uart u;
864 	int i;
865 	int ret=0;
866 
867 	printk(KERN_INFO "Trying %s at iobase 0x%lx irq %u\n", dev->name, dev->base_addr, dev->irq);
868 
869 	if (!yp->bitrate)
870 		return -ENXIO;
871 	if (!dev->base_addr || dev->base_addr > 0x1000 - YAM_EXTENT ||
872 		dev->irq < 2 || dev->irq > 15) {
873 		return -ENXIO;
874 	}
875 	if (!request_region(dev->base_addr, YAM_EXTENT, dev->name))
876 	{
877 		printk(KERN_ERR "%s: cannot 0x%lx busy\n", dev->name, dev->base_addr);
878 		return -EACCES;
879 	}
880 	if ((u = yam_check_uart(dev->base_addr)) == c_uart_unknown) {
881 		printk(KERN_ERR "%s: cannot find uart type\n", dev->name);
882 		ret = -EIO;
883 		goto out_release_base;
884 	}
885 	if (fpga_download(dev->base_addr, yp->bitrate)) {
886 		printk(KERN_ERR "%s: cannot init FPGA\n", dev->name);
887 		ret = -EIO;
888 		goto out_release_base;
889 	}
890 	outb(0, IER(dev->base_addr));
891 	if (request_irq(dev->irq, yam_interrupt, IRQF_SHARED, dev->name, dev)) {
892 		printk(KERN_ERR "%s: irq %d busy\n", dev->name, dev->irq);
893 		ret = -EBUSY;
894 		goto out_release_base;
895 	}
896 
897 	yam_set_uart(dev);
898 
899 	netif_start_queue(dev);
900 
901 	yp->slotcnt = yp->slot / 10;
902 
903 	/* Reset overruns for all ports - FPGA programming makes overruns */
904 	for (i = 0; i < NR_PORTS; i++) {
905 		struct net_device *yam_dev = yam_devs[i];
906 
907 		inb(LSR(yam_dev->base_addr));
908 		yam_dev->stats.rx_fifo_errors = 0;
909 	}
910 
911 	printk(KERN_INFO "%s at iobase 0x%lx irq %u uart %s\n", dev->name, dev->base_addr, dev->irq,
912 		   uart_str[u]);
913 	return 0;
914 
915 out_release_base:
916 	release_region(dev->base_addr, YAM_EXTENT);
917 	return ret;
918 }
919 
920 /* --------------------------------------------------------------------- */
921 
922 static int yam_close(struct net_device *dev)
923 {
924 	struct sk_buff *skb;
925 	struct yam_port *yp = netdev_priv(dev);
926 
927 	if (!dev)
928 		return -EINVAL;
929 
930 	/*
931 	 * disable interrupts
932 	 */
933 	outb(0, IER(dev->base_addr));
934 	outb(1, MCR(dev->base_addr));
935 	/* Remove IRQ handler if last */
936 	free_irq(dev->irq,dev);
937 	release_region(dev->base_addr, YAM_EXTENT);
938 	netif_stop_queue(dev);
939 	while ((skb = skb_dequeue(&yp->send_queue)))
940 		dev_kfree_skb(skb);
941 
942 	printk(KERN_INFO "%s: close yam at iobase 0x%lx irq %u\n",
943 		   yam_drvname, dev->base_addr, dev->irq);
944 	return 0;
945 }
946 
947 /* --------------------------------------------------------------------- */
948 
949 static int yam_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
950 {
951 	struct yam_port *yp = netdev_priv(dev);
952 	struct yamdrv_ioctl_cfg yi;
953 	struct yamdrv_ioctl_mcs *ym;
954 	int ioctl_cmd;
955 
956 	if (copy_from_user(&ioctl_cmd, ifr->ifr_data, sizeof(int)))
957 		 return -EFAULT;
958 
959 	if (yp->magic != YAM_MAGIC)
960 		return -EINVAL;
961 
962 	if (!capable(CAP_NET_ADMIN))
963 		return -EPERM;
964 
965 	if (cmd != SIOCDEVPRIVATE)
966 		return -EINVAL;
967 
968 	switch (ioctl_cmd) {
969 
970 	case SIOCYAMRESERVED:
971 		return -EINVAL;			/* unused */
972 
973 	case SIOCYAMSMCS:
974 		if (netif_running(dev))
975 			return -EINVAL;		/* Cannot change this parameter when up */
976 		if ((ym = kmalloc(sizeof(struct yamdrv_ioctl_mcs), GFP_KERNEL)) == NULL)
977 			return -ENOBUFS;
978 		if (copy_from_user(ym, ifr->ifr_data, sizeof(struct yamdrv_ioctl_mcs))) {
979 			kfree(ym);
980 			return -EFAULT;
981 		}
982 		if (ym->bitrate > YAM_MAXBITRATE) {
983 			kfree(ym);
984 			return -EINVAL;
985 		}
986 		/* setting predef as 0 for loading userdefined mcs data */
987 		add_mcs(ym->bits, ym->bitrate, 0);
988 		kfree(ym);
989 		break;
990 
991 	case SIOCYAMSCFG:
992 		if (!capable(CAP_SYS_RAWIO))
993 			return -EPERM;
994 		if (copy_from_user(&yi, ifr->ifr_data, sizeof(struct yamdrv_ioctl_cfg)))
995 			 return -EFAULT;
996 
997 		if ((yi.cfg.mask & YAM_IOBASE) && netif_running(dev))
998 			return -EINVAL;		/* Cannot change this parameter when up */
999 		if ((yi.cfg.mask & YAM_IRQ) && netif_running(dev))
1000 			return -EINVAL;		/* Cannot change this parameter when up */
1001 		if ((yi.cfg.mask & YAM_BITRATE) && netif_running(dev))
1002 			return -EINVAL;		/* Cannot change this parameter when up */
1003 		if ((yi.cfg.mask & YAM_BAUDRATE) && netif_running(dev))
1004 			return -EINVAL;		/* Cannot change this parameter when up */
1005 
1006 		if (yi.cfg.mask & YAM_IOBASE) {
1007 			yp->iobase = yi.cfg.iobase;
1008 			dev->base_addr = yi.cfg.iobase;
1009 		}
1010 		if (yi.cfg.mask & YAM_IRQ) {
1011 			if (yi.cfg.irq > 15)
1012 				return -EINVAL;
1013 			yp->irq = yi.cfg.irq;
1014 			dev->irq = yi.cfg.irq;
1015 		}
1016 		if (yi.cfg.mask & YAM_BITRATE) {
1017 			if (yi.cfg.bitrate > YAM_MAXBITRATE)
1018 				return -EINVAL;
1019 			yp->bitrate = yi.cfg.bitrate;
1020 		}
1021 		if (yi.cfg.mask & YAM_BAUDRATE) {
1022 			if (yi.cfg.baudrate > YAM_MAXBAUDRATE)
1023 				return -EINVAL;
1024 			yp->baudrate = yi.cfg.baudrate;
1025 		}
1026 		if (yi.cfg.mask & YAM_MODE) {
1027 			if (yi.cfg.mode > YAM_MAXMODE)
1028 				return -EINVAL;
1029 			yp->dupmode = yi.cfg.mode;
1030 		}
1031 		if (yi.cfg.mask & YAM_HOLDDLY) {
1032 			if (yi.cfg.holddly > YAM_MAXHOLDDLY)
1033 				return -EINVAL;
1034 			yp->holdd = yi.cfg.holddly;
1035 		}
1036 		if (yi.cfg.mask & YAM_TXDELAY) {
1037 			if (yi.cfg.txdelay > YAM_MAXTXDELAY)
1038 				return -EINVAL;
1039 			yp->txd = yi.cfg.txdelay;
1040 		}
1041 		if (yi.cfg.mask & YAM_TXTAIL) {
1042 			if (yi.cfg.txtail > YAM_MAXTXTAIL)
1043 				return -EINVAL;
1044 			yp->txtail = yi.cfg.txtail;
1045 		}
1046 		if (yi.cfg.mask & YAM_PERSIST) {
1047 			if (yi.cfg.persist > YAM_MAXPERSIST)
1048 				return -EINVAL;
1049 			yp->pers = yi.cfg.persist;
1050 		}
1051 		if (yi.cfg.mask & YAM_SLOTTIME) {
1052 			if (yi.cfg.slottime > YAM_MAXSLOTTIME)
1053 				return -EINVAL;
1054 			yp->slot = yi.cfg.slottime;
1055 			yp->slotcnt = yp->slot / 10;
1056 		}
1057 		break;
1058 
1059 	case SIOCYAMGCFG:
1060 		memset(&yi, 0, sizeof(yi));
1061 		yi.cfg.mask = 0xffffffff;
1062 		yi.cfg.iobase = yp->iobase;
1063 		yi.cfg.irq = yp->irq;
1064 		yi.cfg.bitrate = yp->bitrate;
1065 		yi.cfg.baudrate = yp->baudrate;
1066 		yi.cfg.mode = yp->dupmode;
1067 		yi.cfg.txdelay = yp->txd;
1068 		yi.cfg.holddly = yp->holdd;
1069 		yi.cfg.txtail = yp->txtail;
1070 		yi.cfg.persist = yp->pers;
1071 		yi.cfg.slottime = yp->slot;
1072 		if (copy_to_user(ifr->ifr_data, &yi, sizeof(struct yamdrv_ioctl_cfg)))
1073 			 return -EFAULT;
1074 		break;
1075 
1076 	default:
1077 		return -EINVAL;
1078 
1079 	}
1080 
1081 	return 0;
1082 }
1083 
1084 /* --------------------------------------------------------------------- */
1085 
1086 static int yam_set_mac_address(struct net_device *dev, void *addr)
1087 {
1088 	struct sockaddr *sa = (struct sockaddr *) addr;
1089 
1090 	/* addr is an AX.25 shifted ASCII mac address */
1091 	memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
1092 	return 0;
1093 }
1094 
1095 /* --------------------------------------------------------------------- */
1096 
1097 static const struct net_device_ops yam_netdev_ops = {
1098 	.ndo_open	     = yam_open,
1099 	.ndo_stop	     = yam_close,
1100 	.ndo_start_xmit      = yam_send_packet,
1101 	.ndo_do_ioctl 	     = yam_ioctl,
1102 	.ndo_set_mac_address = yam_set_mac_address,
1103 };
1104 
1105 static void yam_setup(struct net_device *dev)
1106 {
1107 	struct yam_port *yp = netdev_priv(dev);
1108 
1109 	yp->magic = YAM_MAGIC;
1110 	yp->bitrate = DEFAULT_BITRATE;
1111 	yp->baudrate = DEFAULT_BITRATE * 2;
1112 	yp->iobase = 0;
1113 	yp->irq = 0;
1114 	yp->dupmode = 0;
1115 	yp->holdd = DEFAULT_HOLDD;
1116 	yp->txd = DEFAULT_TXD;
1117 	yp->txtail = DEFAULT_TXTAIL;
1118 	yp->slot = DEFAULT_SLOT;
1119 	yp->pers = DEFAULT_PERS;
1120 	yp->dev = dev;
1121 
1122 	dev->base_addr = yp->iobase;
1123 	dev->irq = yp->irq;
1124 
1125 	skb_queue_head_init(&yp->send_queue);
1126 
1127 	dev->netdev_ops = &yam_netdev_ops;
1128 	dev->header_ops = &ax25_header_ops;
1129 
1130 	dev->type = ARPHRD_AX25;
1131 	dev->hard_header_len = AX25_MAX_HEADER_LEN;
1132 	dev->mtu = AX25_MTU;
1133 	dev->addr_len = AX25_ADDR_LEN;
1134 	memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
1135 	memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
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 			pr_err("yam: cannot allocate net device\n");
1153 			err = -ENOMEM;
1154 			goto error;
1155 		}
1156 
1157 		err = register_netdev(dev);
1158 		if (err) {
1159 			printk(KERN_WARNING "yam: cannot register net device %s\n", dev->name);
1160 			goto error;
1161 		}
1162 		yam_devs[i] = dev;
1163 
1164 	}
1165 
1166 	yam_timer.function = yam_dotimer;
1167 	yam_timer.expires = jiffies + HZ / 100;
1168 	add_timer(&yam_timer);
1169 
1170 	proc_create("yam", S_IRUGO, init_net.proc_net, &yam_info_fops);
1171 	return 0;
1172  error:
1173 	while (--i >= 0) {
1174 		unregister_netdev(yam_devs[i]);
1175 		free_netdev(yam_devs[i]);
1176 	}
1177 	return err;
1178 }
1179 
1180 /* --------------------------------------------------------------------- */
1181 
1182 static void __exit yam_cleanup_driver(void)
1183 {
1184 	struct yam_mcs *p;
1185 	int i;
1186 
1187 	del_timer(&yam_timer);
1188 	for (i = 0; i < NR_PORTS; i++) {
1189 		struct net_device *dev = yam_devs[i];
1190 		if (dev) {
1191 			unregister_netdev(dev);
1192 			free_netdev(dev);
1193 		}
1194 	}
1195 
1196 	while (yam_data) {
1197 		p = yam_data;
1198 		yam_data = yam_data->next;
1199 		kfree(p);
1200 	}
1201 
1202 	remove_proc_entry("yam", init_net.proc_net);
1203 }
1204 
1205 /* --------------------------------------------------------------------- */
1206 
1207 MODULE_AUTHOR("Frederic Rible F1OAT frible@teaser.fr");
1208 MODULE_DESCRIPTION("Yam amateur radio modem driver");
1209 MODULE_LICENSE("GPL");
1210 MODULE_FIRMWARE(FIRMWARE_1200);
1211 MODULE_FIRMWARE(FIRMWARE_9600);
1212 
1213 module_init(yam_init_driver);
1214 module_exit(yam_cleanup_driver);
1215 
1216 /* --------------------------------------------------------------------- */
1217 
1218