mkiss.c revision ddbe9a686805c36a0e68451ebb8cb51b21d0c718 
1/*
2 *  This program is free software; you can distribute it and/or modify it
3 *  under the terms of the GNU General Public License (Version 2) as
4 *  published by the Free Software Foundation.
5 *
6 *  This program is distributed in the hope it will be useful, but WITHOUT
7 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
8 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
9 *  for more details.
10 *
11 *  You should have received a copy of the GNU General Public License along
12 *  with this program; if not, write to the Free Software Foundation, Inc.,
13 *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
14 *
15 * Copyright (C) Hans Alblas PE1AYX <hans@esrac.ele.tue.nl>
16 * Copyright (C) 2004, 05 Ralf Baechle DL5RB <ralf@linux-mips.org>
17 * Copyright (C) 2004, 05 Thomas Osterried DL9SAU <thomas@x-berg.in-berlin.de>
18 */
19#include <linux/module.h>
20#include <asm/system.h>
21#include <linux/bitops.h>
22#include <asm/uaccess.h>
23#include <linux/crc16.h>
24#include <linux/string.h>
25#include <linux/mm.h>
26#include <linux/interrupt.h>
27#include <linux/in.h>
28#include <linux/inet.h>
29#include <linux/tty.h>
30#include <linux/errno.h>
31#include <linux/netdevice.h>
32#include <linux/major.h>
33#include <linux/init.h>
34#include <linux/rtnetlink.h>
35#include <linux/etherdevice.h>
36#include <linux/skbuff.h>
37#include <linux/if_arp.h>
38#include <linux/jiffies.h>
39
40#include <net/ax25.h>
41
42#define AX_MTU		236
43
44/* SLIP/KISS protocol characters. */
45#define END             0300		/* indicates end of frame	*/
46#define ESC             0333		/* indicates byte stuffing	*/
47#define ESC_END         0334		/* ESC ESC_END means END 'data'	*/
48#define ESC_ESC         0335		/* ESC ESC_ESC means ESC 'data'	*/
49
50struct mkiss {
51	struct tty_struct	*tty;	/* ptr to TTY structure		*/
52	struct net_device	*dev;	/* easy for intr handling	*/
53
54	/* These are pointers to the malloc()ed frame buffers. */
55	spinlock_t		buflock;/* lock for rbuf and xbuf */
56	unsigned char		*rbuff;	/* receiver buffer		*/
57	int			rcount;	/* received chars counter       */
58	unsigned char		*xbuff;	/* transmitter buffer		*/
59	unsigned char		*xhead;	/* pointer to next byte to XMIT */
60	int			xleft;	/* bytes left in XMIT queue     */
61
62	/* Detailed SLIP statistics. */
63	int		mtu;		/* Our mtu (to spot changes!)   */
64	int		buffsize;	/* Max buffers sizes            */
65
66	unsigned long	flags;		/* Flag values/ mode etc	*/
67					/* long req'd: used by set_bit --RR */
68#define AXF_INUSE	0		/* Channel in use               */
69#define AXF_ESCAPE	1               /* ESC received                 */
70#define AXF_ERROR	2               /* Parity, etc. error           */
71#define AXF_KEEPTEST	3		/* Keepalive test flag		*/
72#define AXF_OUTWAIT	4		/* is outpacket was flag	*/
73
74	int		mode;
75        int		crcmode;	/* MW: for FlexNet, SMACK etc.  */
76	int		crcauto;	/* CRC auto mode */
77
78#define CRC_MODE_NONE		0
79#define CRC_MODE_FLEX		1
80#define CRC_MODE_SMACK		2
81#define CRC_MODE_FLEX_TEST	3
82#define CRC_MODE_SMACK_TEST	4
83
84	atomic_t		refcnt;
85	struct semaphore	dead_sem;
86};
87
88/*---------------------------------------------------------------------------*/
89
90static const unsigned short crc_flex_table[] = {
91	0x0f87, 0x1e0e, 0x2c95, 0x3d1c, 0x49a3, 0x582a, 0x6ab1, 0x7b38,
92	0x83cf, 0x9246, 0xa0dd, 0xb154, 0xc5eb, 0xd462, 0xe6f9, 0xf770,
93	0x1f06, 0x0e8f, 0x3c14, 0x2d9d, 0x5922, 0x48ab, 0x7a30, 0x6bb9,
94	0x934e, 0x82c7, 0xb05c, 0xa1d5, 0xd56a, 0xc4e3, 0xf678, 0xe7f1,
95	0x2e85, 0x3f0c, 0x0d97, 0x1c1e, 0x68a1, 0x7928, 0x4bb3, 0x5a3a,
96	0xa2cd, 0xb344, 0x81df, 0x9056, 0xe4e9, 0xf560, 0xc7fb, 0xd672,
97	0x3e04, 0x2f8d, 0x1d16, 0x0c9f, 0x7820, 0x69a9, 0x5b32, 0x4abb,
98	0xb24c, 0xa3c5, 0x915e, 0x80d7, 0xf468, 0xe5e1, 0xd77a, 0xc6f3,
99	0x4d83, 0x5c0a, 0x6e91, 0x7f18, 0x0ba7, 0x1a2e, 0x28b5, 0x393c,
100	0xc1cb, 0xd042, 0xe2d9, 0xf350, 0x87ef, 0x9666, 0xa4fd, 0xb574,
101	0x5d02, 0x4c8b, 0x7e10, 0x6f99, 0x1b26, 0x0aaf, 0x3834, 0x29bd,
102	0xd14a, 0xc0c3, 0xf258, 0xe3d1, 0x976e, 0x86e7, 0xb47c, 0xa5f5,
103	0x6c81, 0x7d08, 0x4f93, 0x5e1a, 0x2aa5, 0x3b2c, 0x09b7, 0x183e,
104	0xe0c9, 0xf140, 0xc3db, 0xd252, 0xa6ed, 0xb764, 0x85ff, 0x9476,
105	0x7c00, 0x6d89, 0x5f12, 0x4e9b, 0x3a24, 0x2bad, 0x1936, 0x08bf,
106	0xf048, 0xe1c1, 0xd35a, 0xc2d3, 0xb66c, 0xa7e5, 0x957e, 0x84f7,
107	0x8b8f, 0x9a06, 0xa89d, 0xb914, 0xcdab, 0xdc22, 0xeeb9, 0xff30,
108	0x07c7, 0x164e, 0x24d5, 0x355c, 0x41e3, 0x506a, 0x62f1, 0x7378,
109	0x9b0e, 0x8a87, 0xb81c, 0xa995, 0xdd2a, 0xcca3, 0xfe38, 0xefb1,
110	0x1746, 0x06cf, 0x3454, 0x25dd, 0x5162, 0x40eb, 0x7270, 0x63f9,
111	0xaa8d, 0xbb04, 0x899f, 0x9816, 0xeca9, 0xfd20, 0xcfbb, 0xde32,
112	0x26c5, 0x374c, 0x05d7, 0x145e, 0x60e1, 0x7168, 0x43f3, 0x527a,
113	0xba0c, 0xab85, 0x991e, 0x8897, 0xfc28, 0xeda1, 0xdf3a, 0xceb3,
114	0x3644, 0x27cd, 0x1556, 0x04df, 0x7060, 0x61e9, 0x5372, 0x42fb,
115	0xc98b, 0xd802, 0xea99, 0xfb10, 0x8faf, 0x9e26, 0xacbd, 0xbd34,
116	0x45c3, 0x544a, 0x66d1, 0x7758, 0x03e7, 0x126e, 0x20f5, 0x317c,
117	0xd90a, 0xc883, 0xfa18, 0xeb91, 0x9f2e, 0x8ea7, 0xbc3c, 0xadb5,
118	0x5542, 0x44cb, 0x7650, 0x67d9, 0x1366, 0x02ef, 0x3074, 0x21fd,
119	0xe889, 0xf900, 0xcb9b, 0xda12, 0xaead, 0xbf24, 0x8dbf, 0x9c36,
120	0x64c1, 0x7548, 0x47d3, 0x565a, 0x22e5, 0x336c, 0x01f7, 0x107e,
121	0xf808, 0xe981, 0xdb1a, 0xca93, 0xbe2c, 0xafa5, 0x9d3e, 0x8cb7,
122	0x7440, 0x65c9, 0x5752, 0x46db, 0x3264, 0x23ed, 0x1176, 0x00ff
123};
124
125static unsigned short calc_crc_flex(unsigned char *cp, int size)
126{
127	unsigned short crc = 0xffff;
128
129	while (size--)
130		crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
131
132	return crc;
133}
134
135static int check_crc_flex(unsigned char *cp, int size)
136{
137	unsigned short crc = 0xffff;
138
139	if (size < 3)
140		return -1;
141
142	while (size--)
143		crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
144
145	if ((crc & 0xffff) != 0x7070)
146		return -1;
147
148	return 0;
149}
150
151static int check_crc_16(unsigned char *cp, int size)
152{
153	unsigned short crc = 0x0000;
154
155	if (size < 3)
156		return -1;
157
158	crc = crc16(0, cp, size);
159
160	if (crc != 0x0000)
161		return -1;
162
163	return 0;
164}
165
166/*
167 * Standard encapsulation
168 */
169
170static int kiss_esc(unsigned char *s, unsigned char *d, int len)
171{
172	unsigned char *ptr = d;
173	unsigned char c;
174
175	/*
176	 * Send an initial END character to flush out any data that may have
177	 * accumulated in the receiver due to line noise.
178	 */
179
180	*ptr++ = END;
181
182	while (len-- > 0) {
183		switch (c = *s++) {
184		case END:
185			*ptr++ = ESC;
186			*ptr++ = ESC_END;
187			break;
188		case ESC:
189			*ptr++ = ESC;
190			*ptr++ = ESC_ESC;
191			break;
192		default:
193			*ptr++ = c;
194			break;
195		}
196	}
197
198	*ptr++ = END;
199
200	return ptr - d;
201}
202
203/*
204 * MW:
205 * OK its ugly, but tell me a better solution without copying the
206 * packet to a temporary buffer :-)
207 */
208static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc,
209	int len)
210{
211	unsigned char *ptr = d;
212	unsigned char c=0;
213
214	*ptr++ = END;
215	while (len > 0) {
216		if (len > 2)
217			c = *s++;
218		else if (len > 1)
219			c = crc >> 8;
220		else if (len > 0)
221			c = crc & 0xff;
222
223		len--;
224
225		switch (c) {
226		case END:
227			*ptr++ = ESC;
228			*ptr++ = ESC_END;
229			break;
230		case ESC:
231			*ptr++ = ESC;
232			*ptr++ = ESC_ESC;
233			break;
234		default:
235			*ptr++ = c;
236			break;
237		}
238	}
239	*ptr++ = END;
240
241	return ptr - d;
242}
243
244/* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
245static void ax_bump(struct mkiss *ax)
246{
247	struct sk_buff *skb;
248	int count;
249
250	spin_lock_bh(&ax->buflock);
251	if (ax->rbuff[0] > 0x0f) {
252		if (ax->rbuff[0] & 0x80) {
253			if (check_crc_16(ax->rbuff, ax->rcount) < 0) {
254				ax->dev->stats.rx_errors++;
255				spin_unlock_bh(&ax->buflock);
256
257				return;
258			}
259			if (ax->crcmode != CRC_MODE_SMACK && ax->crcauto) {
260				printk(KERN_INFO
261				       "mkiss: %s: Switchting to crc-smack\n",
262				       ax->dev->name);
263				ax->crcmode = CRC_MODE_SMACK;
264			}
265			ax->rcount -= 2;
266			*ax->rbuff &= ~0x80;
267		} else if (ax->rbuff[0] & 0x20)  {
268			if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
269				ax->dev->stats.rx_errors++;
270				spin_unlock_bh(&ax->buflock);
271				return;
272			}
273			if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) {
274				printk(KERN_INFO
275				       "mkiss: %s: Switchting to crc-flexnet\n",
276				       ax->dev->name);
277				ax->crcmode = CRC_MODE_FLEX;
278			}
279			ax->rcount -= 2;
280
281			/*
282			 * dl9sau bugfix: the trailling two bytes flexnet crc
283			 * will not be passed to the kernel. thus we have to
284			 * correct the kissparm signature, because it indicates
285			 * a crc but there's none
286			 */
287			*ax->rbuff &= ~0x20;
288		}
289 	}
290
291	count = ax->rcount;
292
293	if ((skb = dev_alloc_skb(count)) == NULL) {
294		printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n",
295		       ax->dev->name);
296		ax->dev->stats.rx_dropped++;
297		spin_unlock_bh(&ax->buflock);
298		return;
299	}
300
301	memcpy(skb_put(skb,count), ax->rbuff, count);
302	skb->protocol = ax25_type_trans(skb, ax->dev);
303	netif_rx(skb);
304	ax->dev->stats.rx_packets++;
305	ax->dev->stats.rx_bytes += count;
306	spin_unlock_bh(&ax->buflock);
307}
308
309static void kiss_unesc(struct mkiss *ax, unsigned char s)
310{
311	switch (s) {
312	case END:
313		/* drop keeptest bit = VSV */
314		if (test_bit(AXF_KEEPTEST, &ax->flags))
315			clear_bit(AXF_KEEPTEST, &ax->flags);
316
317		if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
318			ax_bump(ax);
319
320		clear_bit(AXF_ESCAPE, &ax->flags);
321		ax->rcount = 0;
322		return;
323
324	case ESC:
325		set_bit(AXF_ESCAPE, &ax->flags);
326		return;
327	case ESC_ESC:
328		if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
329			s = ESC;
330		break;
331	case ESC_END:
332		if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
333			s = END;
334		break;
335	}
336
337	spin_lock_bh(&ax->buflock);
338	if (!test_bit(AXF_ERROR, &ax->flags)) {
339		if (ax->rcount < ax->buffsize) {
340			ax->rbuff[ax->rcount++] = s;
341			spin_unlock_bh(&ax->buflock);
342			return;
343		}
344
345		ax->dev->stats.rx_over_errors++;
346		set_bit(AXF_ERROR, &ax->flags);
347	}
348	spin_unlock_bh(&ax->buflock);
349}
350
351static int ax_set_mac_address(struct net_device *dev, void *addr)
352{
353	struct sockaddr_ax25 *sa = addr;
354
355	netif_tx_lock_bh(dev);
356	netif_addr_lock(dev);
357	memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
358	netif_addr_unlock(dev);
359	netif_tx_unlock_bh(dev);
360
361	return 0;
362}
363
364/*---------------------------------------------------------------------------*/
365
366static void ax_changedmtu(struct mkiss *ax)
367{
368	struct net_device *dev = ax->dev;
369	unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
370	int len;
371
372	len = dev->mtu * 2;
373
374	/*
375	 * allow for arrival of larger UDP packets, even if we say not to
376	 * also fixes a bug in which SunOS sends 512-byte packets even with
377	 * an MSS of 128
378	 */
379	if (len < 576 * 2)
380		len = 576 * 2;
381
382	xbuff = kmalloc(len + 4, GFP_ATOMIC);
383	rbuff = kmalloc(len + 4, GFP_ATOMIC);
384
385	if (xbuff == NULL || rbuff == NULL)  {
386		printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, "
387		       "MTU change cancelled.\n",
388		       ax->dev->name);
389		dev->mtu = ax->mtu;
390		kfree(xbuff);
391		kfree(rbuff);
392		return;
393	}
394
395	spin_lock_bh(&ax->buflock);
396
397	oxbuff    = ax->xbuff;
398	ax->xbuff = xbuff;
399	orbuff    = ax->rbuff;
400	ax->rbuff = rbuff;
401
402	if (ax->xleft) {
403		if (ax->xleft <= len) {
404			memcpy(ax->xbuff, ax->xhead, ax->xleft);
405		} else  {
406			ax->xleft = 0;
407			dev->stats.tx_dropped++;
408		}
409	}
410
411	ax->xhead = ax->xbuff;
412
413	if (ax->rcount) {
414		if (ax->rcount <= len) {
415			memcpy(ax->rbuff, orbuff, ax->rcount);
416		} else  {
417			ax->rcount = 0;
418			dev->stats.rx_over_errors++;
419			set_bit(AXF_ERROR, &ax->flags);
420		}
421	}
422
423	ax->mtu      = dev->mtu + 73;
424	ax->buffsize = len;
425
426	spin_unlock_bh(&ax->buflock);
427
428	kfree(oxbuff);
429	kfree(orbuff);
430}
431
432/* Encapsulate one AX.25 packet and stuff into a TTY queue. */
433static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
434{
435	struct mkiss *ax = netdev_priv(dev);
436	unsigned char *p;
437	int actual, count;
438
439	if (ax->mtu != ax->dev->mtu + 73)	/* Someone has been ifconfigging */
440		ax_changedmtu(ax);
441
442	if (len > ax->mtu) {		/* Sigh, shouldn't occur BUT ... */
443		len = ax->mtu;
444		printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
445		dev->stats.tx_dropped++;
446		netif_start_queue(dev);
447		return;
448	}
449
450	p = icp;
451
452	spin_lock_bh(&ax->buflock);
453	if ((*p & 0x0f) != 0) {
454		/* Configuration Command (kissparms(1).
455		 * Protocol spec says: never append CRC.
456		 * This fixes a very old bug in the linux
457		 * kiss driver. -- dl9sau */
458		switch (*p & 0xff) {
459		case 0x85:
460			/* command from userspace especially for us,
461			 * not for delivery to the tnc */
462			if (len > 1) {
463				int cmd = (p[1] & 0xff);
464				switch(cmd) {
465				case 3:
466				  ax->crcmode = CRC_MODE_SMACK;
467				  break;
468				case 2:
469				  ax->crcmode = CRC_MODE_FLEX;
470				  break;
471				case 1:
472				  ax->crcmode = CRC_MODE_NONE;
473				  break;
474				case 0:
475				default:
476				  ax->crcmode = CRC_MODE_SMACK_TEST;
477				  cmd = 0;
478				}
479				ax->crcauto = (cmd ? 0 : 1);
480				printk(KERN_INFO "mkiss: %s: crc mode %s %d\n", ax->dev->name, (len) ? "set to" : "is", cmd);
481			}
482			spin_unlock_bh(&ax->buflock);
483			netif_start_queue(dev);
484
485			return;
486		default:
487			count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
488		}
489	} else {
490		unsigned short crc;
491		switch (ax->crcmode) {
492		case CRC_MODE_SMACK_TEST:
493			ax->crcmode  = CRC_MODE_FLEX_TEST;
494			printk(KERN_INFO "mkiss: %s: Trying crc-smack\n", ax->dev->name);
495			// fall through
496		case CRC_MODE_SMACK:
497			*p |= 0x80;
498			crc = swab16(crc16(0, p, len));
499			count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
500			break;
501		case CRC_MODE_FLEX_TEST:
502			ax->crcmode = CRC_MODE_NONE;
503			printk(KERN_INFO "mkiss: %s: Trying crc-flexnet\n", ax->dev->name);
504			// fall through
505		case CRC_MODE_FLEX:
506			*p |= 0x20;
507			crc = calc_crc_flex(p, len);
508			count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
509			break;
510
511		default:
512			count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
513		}
514  	}
515	spin_unlock_bh(&ax->buflock);
516
517	set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
518	actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
519	dev->stats.tx_packets++;
520	dev->stats.tx_bytes += actual;
521
522	ax->dev->trans_start = jiffies;
523	ax->xleft = count - actual;
524	ax->xhead = ax->xbuff + actual;
525}
526
527/* Encapsulate an AX.25 packet and kick it into a TTY queue. */
528static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
529{
530	struct mkiss *ax = netdev_priv(dev);
531
532	if (!netif_running(dev))  {
533		printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
534		return 1;
535	}
536
537	if (netif_queue_stopped(dev)) {
538		/*
539		 * May be we must check transmitter timeout here ?
540		 *      14 Oct 1994 Dmitry Gorodchanin.
541		 */
542		if (time_before(jiffies, dev->trans_start + 20 * HZ)) {
543			/* 20 sec timeout not reached */
544			return 1;
545		}
546
547		printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
548		       (tty_chars_in_buffer(ax->tty) || ax->xleft) ?
549		       "bad line quality" : "driver error");
550
551		ax->xleft = 0;
552		clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
553		netif_start_queue(dev);
554	}
555
556	/* We were not busy, so we are now... :-) */
557	if (skb != NULL) {
558		netif_stop_queue(dev);
559		ax_encaps(dev, skb->data, skb->len);
560		kfree_skb(skb);
561	}
562
563	return 0;
564}
565
566static int ax_open_dev(struct net_device *dev)
567{
568	struct mkiss *ax = netdev_priv(dev);
569
570	if (ax->tty == NULL)
571		return -ENODEV;
572
573	return 0;
574}
575
576#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
577
578/* Return the frame type ID */
579static int ax_header(struct sk_buff *skb, struct net_device *dev,
580		     unsigned short type, const void *daddr,
581		     const void *saddr, unsigned len)
582{
583#ifdef CONFIG_INET
584	if (type != ETH_P_AX25)
585		return ax25_hard_header(skb, dev, type, daddr, saddr, len);
586#endif
587	return 0;
588}
589
590
591static int ax_rebuild_header(struct sk_buff *skb)
592{
593#ifdef CONFIG_INET
594	return ax25_rebuild_header(skb);
595#else
596	return 0;
597#endif
598}
599
600#endif	/* CONFIG_{AX25,AX25_MODULE} */
601
602/* Open the low-level part of the AX25 channel. Easy! */
603static int ax_open(struct net_device *dev)
604{
605	struct mkiss *ax = netdev_priv(dev);
606	unsigned long len;
607
608	if (ax->tty == NULL)
609		return -ENODEV;
610
611	/*
612	 * Allocate the frame buffers:
613	 *
614	 * rbuff	Receive buffer.
615	 * xbuff	Transmit buffer.
616	 */
617	len = dev->mtu * 2;
618
619	/*
620	 * allow for arrival of larger UDP packets, even if we say not to
621	 * also fixes a bug in which SunOS sends 512-byte packets even with
622	 * an MSS of 128
623	 */
624	if (len < 576 * 2)
625		len = 576 * 2;
626
627	if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
628		goto norbuff;
629
630	if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
631		goto noxbuff;
632
633	ax->mtu	     = dev->mtu + 73;
634	ax->buffsize = len;
635	ax->rcount   = 0;
636	ax->xleft    = 0;
637
638	ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
639
640	spin_lock_init(&ax->buflock);
641
642	return 0;
643
644noxbuff:
645	kfree(ax->rbuff);
646
647norbuff:
648	return -ENOMEM;
649}
650
651
652/* Close the low-level part of the AX25 channel. Easy! */
653static int ax_close(struct net_device *dev)
654{
655	struct mkiss *ax = netdev_priv(dev);
656
657	if (ax->tty)
658		clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
659
660	netif_stop_queue(dev);
661
662	return 0;
663}
664
665static const struct header_ops ax_header_ops = {
666	.create    = ax_header,
667	.rebuild   = ax_rebuild_header,
668};
669
670static void ax_setup(struct net_device *dev)
671{
672	/* Finish setting up the DEVICE info. */
673	dev->mtu             = AX_MTU;
674	dev->hard_start_xmit = ax_xmit;
675	dev->open            = ax_open_dev;
676	dev->stop            = ax_close;
677	dev->set_mac_address = ax_set_mac_address;
678	dev->hard_header_len = 0;
679	dev->addr_len        = 0;
680	dev->type            = ARPHRD_AX25;
681	dev->tx_queue_len    = 10;
682	dev->header_ops      = &ax_header_ops;
683
684
685	memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
686	memcpy(dev->dev_addr,  &ax25_defaddr,  AX25_ADDR_LEN);
687
688	dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
689}
690
691/*
692 * We have a potential race on dereferencing tty->disc_data, because the tty
693 * layer provides no locking at all - thus one cpu could be running
694 * sixpack_receive_buf while another calls sixpack_close, which zeroes
695 * tty->disc_data and frees the memory that sixpack_receive_buf is using.  The
696 * best way to fix this is to use a rwlock in the tty struct, but for now we
697 * use a single global rwlock for all ttys in ppp line discipline.
698 */
699static DEFINE_RWLOCK(disc_data_lock);
700
701static struct mkiss *mkiss_get(struct tty_struct *tty)
702{
703	struct mkiss *ax;
704
705	read_lock(&disc_data_lock);
706	ax = tty->disc_data;
707	if (ax)
708		atomic_inc(&ax->refcnt);
709	read_unlock(&disc_data_lock);
710
711	return ax;
712}
713
714static void mkiss_put(struct mkiss *ax)
715{
716	if (atomic_dec_and_test(&ax->refcnt))
717		up(&ax->dead_sem);
718}
719
720static int crc_force = 0;	/* Can be overridden with insmod */
721
722static int mkiss_open(struct tty_struct *tty)
723{
724	struct net_device *dev;
725	struct mkiss *ax;
726	int err;
727
728	if (!capable(CAP_NET_ADMIN))
729		return -EPERM;
730	if (tty->ops->write == NULL)
731		return -EOPNOTSUPP;
732
733	dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup);
734	if (!dev) {
735		err = -ENOMEM;
736		goto out;
737	}
738
739	ax = netdev_priv(dev);
740	ax->dev = dev;
741
742	spin_lock_init(&ax->buflock);
743	atomic_set(&ax->refcnt, 1);
744	init_MUTEX_LOCKED(&ax->dead_sem);
745
746	ax->tty = tty;
747	tty->disc_data = ax;
748	tty->receive_room = 65535;
749
750	tty_driver_flush_buffer(tty);
751
752	/* Restore default settings */
753	dev->type = ARPHRD_AX25;
754
755	/* Perform the low-level AX25 initialization. */
756	if ((err = ax_open(ax->dev))) {
757		goto out_free_netdev;
758	}
759
760	if (register_netdev(dev))
761		goto out_free_buffers;
762
763	/* after register_netdev() - because else printk smashes the kernel */
764	switch (crc_force) {
765	case 3:
766		ax->crcmode  = CRC_MODE_SMACK;
767		printk(KERN_INFO "mkiss: %s: crc mode smack forced.\n",
768		       ax->dev->name);
769		break;
770	case 2:
771		ax->crcmode  = CRC_MODE_FLEX;
772		printk(KERN_INFO "mkiss: %s: crc mode flexnet forced.\n",
773		       ax->dev->name);
774		break;
775	case 1:
776		ax->crcmode  = CRC_MODE_NONE;
777		printk(KERN_INFO "mkiss: %s: crc mode disabled.\n",
778		       ax->dev->name);
779		break;
780	case 0:
781		/* fall through */
782	default:
783		crc_force = 0;
784		printk(KERN_INFO "mkiss: %s: crc mode is auto.\n",
785		       ax->dev->name);
786		ax->crcmode  = CRC_MODE_SMACK_TEST;
787	}
788	ax->crcauto = (crc_force ? 0 : 1);
789
790	netif_start_queue(dev);
791
792	/* Done.  We have linked the TTY line to a channel. */
793	return 0;
794
795out_free_buffers:
796	kfree(ax->rbuff);
797	kfree(ax->xbuff);
798
799out_free_netdev:
800	free_netdev(dev);
801
802out:
803	return err;
804}
805
806static void mkiss_close(struct tty_struct *tty)
807{
808	struct mkiss *ax;
809
810	write_lock(&disc_data_lock);
811	ax = tty->disc_data;
812	tty->disc_data = NULL;
813	write_unlock(&disc_data_lock);
814
815	if (!ax)
816		return;
817
818	/*
819	 * We have now ensured that nobody can start using ap from now on, but
820	 * we have to wait for all existing users to finish.
821	 */
822	if (!atomic_dec_and_test(&ax->refcnt))
823		down(&ax->dead_sem);
824
825	unregister_netdev(ax->dev);
826
827	/* Free all AX25 frame buffers. */
828	kfree(ax->rbuff);
829	kfree(ax->xbuff);
830
831	ax->tty = NULL;
832}
833
834/* Perform I/O control on an active ax25 channel. */
835static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
836	unsigned int cmd, unsigned long arg)
837{
838	struct mkiss *ax = mkiss_get(tty);
839	struct net_device *dev;
840	unsigned int tmp, err;
841
842	/* First make sure we're connected. */
843	if (ax == NULL)
844		return -ENXIO;
845	dev = ax->dev;
846
847	switch (cmd) {
848 	case SIOCGIFNAME:
849		err = copy_to_user((void __user *) arg, ax->dev->name,
850		                   strlen(ax->dev->name) + 1) ? -EFAULT : 0;
851		break;
852
853	case SIOCGIFENCAP:
854		err = put_user(4, (int __user *) arg);
855		break;
856
857	case SIOCSIFENCAP:
858		if (get_user(tmp, (int __user *) arg)) {
859			err = -EFAULT;
860			break;
861		}
862
863		ax->mode = tmp;
864		dev->addr_len        = AX25_ADDR_LEN;
865		dev->hard_header_len = AX25_KISS_HEADER_LEN +
866		                       AX25_MAX_HEADER_LEN + 3;
867		dev->type            = ARPHRD_AX25;
868
869		err = 0;
870		break;
871
872	case SIOCSIFHWADDR: {
873		char addr[AX25_ADDR_LEN];
874
875		if (copy_from_user(&addr,
876		                   (void __user *) arg, AX25_ADDR_LEN)) {
877			err = -EFAULT;
878			break;
879		}
880
881		netif_tx_lock_bh(dev);
882		memcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
883		netif_tx_unlock_bh(dev);
884
885		err = 0;
886		break;
887	}
888	default:
889		err = -ENOIOCTLCMD;
890	}
891
892	mkiss_put(ax);
893
894	return err;
895}
896
897/*
898 * Handle the 'receiver data ready' interrupt.
899 * This function is called by the 'tty_io' module in the kernel when
900 * a block of data has been received, which can now be decapsulated
901 * and sent on to the AX.25 layer for further processing.
902 */
903static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
904	char *fp, int count)
905{
906	struct mkiss *ax = mkiss_get(tty);
907
908	if (!ax)
909		return;
910
911	/*
912	 * Argh! mtu change time! - costs us the packet part received
913	 * at the change
914	 */
915	if (ax->mtu != ax->dev->mtu + 73)
916		ax_changedmtu(ax);
917
918	/* Read the characters out of the buffer */
919	while (count--) {
920		if (fp != NULL && *fp++) {
921			if (!test_and_set_bit(AXF_ERROR, &ax->flags))
922				ax->dev->stats.rx_errors++;
923			cp++;
924			continue;
925		}
926
927		kiss_unesc(ax, *cp++);
928	}
929
930	mkiss_put(ax);
931	tty_unthrottle(tty);
932}
933
934/*
935 * Called by the driver when there's room for more data.  If we have
936 * more packets to send, we send them here.
937 */
938static void mkiss_write_wakeup(struct tty_struct *tty)
939{
940	struct mkiss *ax = mkiss_get(tty);
941	int actual;
942
943	if (!ax)
944		return;
945
946	if (ax->xleft <= 0)  {
947		/* Now serial buffer is almost free & we can start
948		 * transmission of another packet
949		 */
950		clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
951
952		netif_wake_queue(ax->dev);
953		goto out;
954	}
955
956	actual = tty->ops->write(tty, ax->xhead, ax->xleft);
957	ax->xleft -= actual;
958	ax->xhead += actual;
959
960out:
961	mkiss_put(ax);
962}
963
964static struct tty_ldisc_ops ax_ldisc = {
965	.owner		= THIS_MODULE,
966	.magic		= TTY_LDISC_MAGIC,
967	.name		= "mkiss",
968	.open		= mkiss_open,
969	.close		= mkiss_close,
970	.ioctl		= mkiss_ioctl,
971	.receive_buf	= mkiss_receive_buf,
972	.write_wakeup	= mkiss_write_wakeup
973};
974
975static char banner[] __initdata = KERN_INFO \
976	"mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
977static char msg_regfail[] __initdata = KERN_ERR \
978	"mkiss: can't register line discipline (err = %d)\n";
979
980static int __init mkiss_init_driver(void)
981{
982	int status;
983
984	printk(banner);
985
986	if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0)
987		printk(msg_regfail);
988
989	return status;
990}
991
992static const char msg_unregfail[] __exitdata = KERN_ERR \
993	"mkiss: can't unregister line discipline (err = %d)\n";
994
995static void __exit mkiss_exit_driver(void)
996{
997	int ret;
998
999	if ((ret = tty_unregister_ldisc(N_AX25)))
1000		printk(msg_unregfail, ret);
1001}
1002
1003MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
1004MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
1005module_param(crc_force, int, 0);
1006MODULE_PARM_DESC(crc_force, "crc [0 = auto | 1 = none | 2 = flexnet | 3 = smack]");
1007MODULE_LICENSE("GPL");
1008MODULE_ALIAS_LDISC(N_AX25);
1009
1010module_init(mkiss_init_driver);
1011module_exit(mkiss_exit_driver);
1012