blob: ac191ef2119b1c4401775d5a54d0adeb411b0081 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Ralf Baechle815f62b2005-08-24 18:06:36 +01002 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
Ralf Baechle815f62b2005-08-24 18:06:36 +01006 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
Ralf Baechle815f62b2005-08-24 18:06:36 +010011 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 *
Ralf Baechle815f62b2005-08-24 18:06:36 +010015 * Copyright (C) Hans Alblas PE1AYX <hans@esrac.ele.tue.nl>
16 * Copyright (C) 2004, 05 Ralf Baechle DL5RB <ralf@linux-mips.org>
Ralf Baechle5793f4b2005-10-14 14:28:09 +010017 * Copyright (C) 2004, 05 Thomas Osterried DL9SAU <thomas@x-berg.in-berlin.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/module.h>
20#include <asm/system.h>
21#include <linux/bitops.h>
22#include <asm/uaccess.h>
Ralf Baechle5793f4b2005-10-14 14:28:09 +010023#include <linux/crc16.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#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>
Marcelo Feitoza Parisicd8749b2005-07-15 11:16:42 +010038#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#include <net/ax25.h>
41
Ralf Baechle815f62b2005-08-24 18:06:36 +010042#define AX_MTU 236
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Ralf Baechle815f62b2005-08-24 18:06:36 +010044/* 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' */
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Ralf Baechle815f62b2005-08-24 18:06:36 +010050struct mkiss {
51 struct tty_struct *tty; /* ptr to TTY structure */
52 struct net_device *dev; /* easy for intr handling */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Ralf Baechle815f62b2005-08-24 18:06:36 +010054 /* 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Ralf Baechle815f62b2005-08-24 18:06:36 +010062 /* Detailed SLIP statistics. */
63 int mtu; /* Our mtu (to spot changes!) */
64 int buffsize; /* Max buffers sizes */
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Ralf Baechle815f62b2005-08-24 18:06:36 +010066 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Ralf Baechle815f62b2005-08-24 18:06:36 +010074 int mode;
75 int crcmode; /* MW: for FlexNet, SMACK etc. */
Ralf Baechle5793f4b2005-10-14 14:28:09 +010076 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
Ralf Baechle815f62b2005-08-24 18:06:36 +010083
84 atomic_t refcnt;
85 struct semaphore dead_sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086};
87
88/*---------------------------------------------------------------------------*/
89
Ralf Baechle815f62b2005-08-24 18:06:36 +010090static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static unsigned short calc_crc_flex(unsigned char *cp, int size)
126{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100127 unsigned short crc = 0xffff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Ralf Baechle815f62b2005-08-24 18:06:36 +0100129 while (size--)
130 crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
131
132 return crc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135static int check_crc_flex(unsigned char *cp, int size)
136{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100137 unsigned short crc = 0xffff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Ralf Baechle815f62b2005-08-24 18:06:36 +0100139 if (size < 3)
140 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Ralf Baechle815f62b2005-08-24 18:06:36 +0100142 while (size--)
143 crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Ralf Baechle815f62b2005-08-24 18:06:36 +0100145 if ((crc & 0xffff) != 0x7070)
146 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Ralf Baechle815f62b2005-08-24 18:06:36 +0100148 return 0;
149}
150
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100151static 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
Ralf Baechle815f62b2005-08-24 18:06:36 +0100166/*
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) {
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100252 if (ax->rbuff[0] & 0x80) {
253 if (check_crc_16(ax->rbuff, ax->rcount) < 0) {
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000254 ax->dev->stats.rx_errors++;
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100255 spin_unlock_bh(&ax->buflock);
256
Ralf Baechle815f62b2005-08-24 18:06:36 +0100257 return;
258 }
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100259 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 }
Ralf Baechle815f62b2005-08-24 18:06:36 +0100265 ax->rcount -= 2;
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100266 *ax->rbuff &= ~0x80;
267 } else if (ax->rbuff[0] & 0x20) {
268 if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000269 ax->dev->stats.rx_errors++;
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100270 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
Ralf Baechle815f62b2005-08-24 18:06:36 +0100286 */
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100287 *ax->rbuff &= ~0x20;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100288 }
289 }
Ralf Baechle815f62b2005-08-24 18:06:36 +0100290
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);
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000296 ax->dev->stats.rx_dropped++;
Jarek Poplawski9f30c762008-02-13 11:17:58 +0000297 spin_unlock_bh(&ax->buflock);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100298 return;
299 }
300
Ralf Baechle815f62b2005-08-24 18:06:36 +0100301 memcpy(skb_put(skb,count), ax->rbuff, count);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100302 skb->protocol = ax25_type_trans(skb, ax->dev);
303 netif_rx(skb);
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000304 ax->dev->stats.rx_packets++;
305 ax->dev->stats.rx_bytes += count;
Jarek Poplawski9f30c762008-02-13 11:17:58 +0000306 spin_unlock_bh(&ax->buflock);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100307}
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
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000345 ax->dev->stats.rx_over_errors++;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100346 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
Herbert Xu932ff272006-06-09 12:20:56 -0700355 netif_tx_lock_bh(dev);
David S. Millere308a5d2008-07-15 00:13:44 -0700356 netif_addr_lock(dev);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100357 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
David S. Millere308a5d2008-07-15 00:13:44 -0700358 netif_addr_unlock(dev);
Herbert Xu932ff272006-06-09 12:20:56 -0700359 netif_tx_unlock_bh(dev);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100360
361 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362}
363
364/*---------------------------------------------------------------------------*/
365
Ralf Baechle815f62b2005-08-24 18:06:36 +0100366static void ax_changedmtu(struct mkiss *ax)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
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) {
Ralf Baechle815f62b2005-08-24 18:06:36 +0100386 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, "
387 "MTU change cancelled.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 ax->dev->name);
389 dev->mtu = ax->mtu;
Jesper Juhlb4558ea2005-10-28 16:53:13 -0400390 kfree(xbuff);
391 kfree(rbuff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 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;
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000407 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 }
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;
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000418 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 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
Ralf Baechle815f62b2005-08-24 18:06:36 +0100428 kfree(oxbuff);
429 kfree(orbuff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430}
431
432/* Encapsulate one AX.25 packet and stuff into a TTY queue. */
Ralf Baechle815f62b2005-08-24 18:06:36 +0100433static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100435 struct mkiss *ax = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 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);
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000445 dev->stats.tx_dropped++;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100446 netif_start_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 return;
448 }
449
450 p = icp;
451
452 spin_lock_bh(&ax->buflock);
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100453 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100485 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100511 default:
512 count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
513 }
514 }
Ralf Baechlec1854eb2006-01-08 22:31:04 -0800515 spin_unlock_bh(&ax->buflock);
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100516
Ralf Baechle815f62b2005-08-24 18:06:36 +0100517 set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700518 actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000519 dev->stats.tx_packets++;
520 dev->stats.tx_bytes += actual;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 ax->dev->trans_start = jiffies;
523 ax->xleft = count - actual;
524 ax->xhead = ax->xbuff + actual;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525}
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527/* 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{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100530 struct mkiss *ax = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532 if (!netif_running(dev)) {
533 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
Patrick McHardy5b548142009-06-12 06:22:29 +0000534 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 }
536
537 if (netif_queue_stopped(dev)) {
538 /*
539 * May be we must check transmitter timeout here ?
540 * 14 Oct 1994 Dmitry Gorodchanin.
541 */
Marcelo Feitoza Parisicd8749b2005-07-15 11:16:42 +0100542 if (time_before(jiffies, dev->trans_start + 20 * HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 /* 20 sec timeout not reached */
Patrick McHardy5b548142009-06-12 06:22:29 +0000544 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 }
546
547 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
Eugene Teo56087842008-07-30 12:38:59 -0700548 (tty_chars_in_buffer(ax->tty) || ax->xleft) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 "bad line quality" : "driver error");
550
551 ax->xleft = 0;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100552 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
553 netif_start_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
555
556 /* We were not busy, so we are now... :-) */
557 if (skb != NULL) {
Ralf Baechle815f62b2005-08-24 18:06:36 +0100558 netif_stop_queue(dev);
559 ax_encaps(dev, skb->data, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 kfree_skb(skb);
561 }
562
Patrick McHardy6ed10652009-06-23 06:03:08 +0000563 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564}
565
Ralf Baechle815f62b2005-08-24 18:06:36 +0100566static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
577
578/* Return the frame type ID */
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700579static int ax_header(struct sk_buff *skb, struct net_device *dev,
580 unsigned short type, const void *daddr,
581 const void *saddr, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
583#ifdef CONFIG_INET
Al Virod9a19d22007-10-14 19:40:49 +0100584 if (type != ETH_P_AX25)
Ralf Baechle6f749982005-09-12 14:21:01 -0700585 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586#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{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100605 struct mkiss *ax = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 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{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100655 struct mkiss *ax = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Ralf Baechle815f62b2005-08-24 18:06:36 +0100657 if (ax->tty)
658 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
660 netif_stop_queue(dev);
661
662 return 0;
663}
664
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700665static const struct header_ops ax_header_ops = {
666 .create = ax_header,
667 .rebuild = ax_rebuild_header,
668};
669
Stephen Hemminger6095e082009-01-09 13:01:41 +0000670static const struct net_device_ops ax_netdev_ops = {
671 .ndo_open = ax_open_dev,
672 .ndo_stop = ax_close,
673 .ndo_start_xmit = ax_xmit,
674 .ndo_set_mac_address = ax_set_mac_address,
675};
676
Ralf Baechle815f62b2005-08-24 18:06:36 +0100677static void ax_setup(struct net_device *dev)
678{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100679 /* Finish setting up the DEVICE info. */
680 dev->mtu = AX_MTU;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100681 dev->hard_header_len = 0;
682 dev->addr_len = 0;
683 dev->type = ARPHRD_AX25;
684 dev->tx_queue_len = 10;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700685 dev->header_ops = &ax_header_ops;
Stephen Hemminger6095e082009-01-09 13:01:41 +0000686 dev->netdev_ops = &ax_netdev_ops;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700687
Ralf Baechle815f62b2005-08-24 18:06:36 +0100688
Ralf Baechle15b1c0e2006-12-07 15:47:08 -0800689 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
690 memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100691
692 dev->flags = IFF_BROADCAST | IFF_MULTICAST;
693}
694
695/*
696 * We have a potential race on dereferencing tty->disc_data, because the tty
697 * layer provides no locking at all - thus one cpu could be running
698 * sixpack_receive_buf while another calls sixpack_close, which zeroes
699 * tty->disc_data and frees the memory that sixpack_receive_buf is using. The
700 * best way to fix this is to use a rwlock in the tty struct, but for now we
701 * use a single global rwlock for all ttys in ppp line discipline.
702 */
Ralf Baechled5919582005-10-04 12:22:16 +0100703static DEFINE_RWLOCK(disc_data_lock);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100704
705static struct mkiss *mkiss_get(struct tty_struct *tty)
706{
707 struct mkiss *ax;
708
709 read_lock(&disc_data_lock);
710 ax = tty->disc_data;
711 if (ax)
712 atomic_inc(&ax->refcnt);
713 read_unlock(&disc_data_lock);
714
715 return ax;
716}
717
718static void mkiss_put(struct mkiss *ax)
719{
720 if (atomic_dec_and_test(&ax->refcnt))
721 up(&ax->dead_sem);
722}
723
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100724static int crc_force = 0; /* Can be overridden with insmod */
725
Ralf Baechle815f62b2005-08-24 18:06:36 +0100726static int mkiss_open(struct tty_struct *tty)
727{
728 struct net_device *dev;
729 struct mkiss *ax;
730 int err;
731
732 if (!capable(CAP_NET_ADMIN))
733 return -EPERM;
Alan Coxf34d7a52008-04-30 00:54:13 -0700734 if (tty->ops->write == NULL)
735 return -EOPNOTSUPP;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100736
737 dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup);
738 if (!dev) {
739 err = -ENOMEM;
740 goto out;
741 }
742
743 ax = netdev_priv(dev);
744 ax->dev = dev;
745
746 spin_lock_init(&ax->buflock);
747 atomic_set(&ax->refcnt, 1);
748 init_MUTEX_LOCKED(&ax->dead_sem);
749
750 ax->tty = tty;
751 tty->disc_data = ax;
Alan Cox33f0f882006-01-09 20:54:13 -0800752 tty->receive_room = 65535;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100753
Alan Coxf34d7a52008-04-30 00:54:13 -0700754 tty_driver_flush_buffer(tty);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100755
756 /* Restore default settings */
757 dev->type = ARPHRD_AX25;
758
759 /* Perform the low-level AX25 initialization. */
760 if ((err = ax_open(ax->dev))) {
761 goto out_free_netdev;
762 }
763
764 if (register_netdev(dev))
765 goto out_free_buffers;
766
Ralf Baechle5793f4b2005-10-14 14:28:09 +0100767 /* after register_netdev() - because else printk smashes the kernel */
768 switch (crc_force) {
769 case 3:
770 ax->crcmode = CRC_MODE_SMACK;
771 printk(KERN_INFO "mkiss: %s: crc mode smack forced.\n",
772 ax->dev->name);
773 break;
774 case 2:
775 ax->crcmode = CRC_MODE_FLEX;
776 printk(KERN_INFO "mkiss: %s: crc mode flexnet forced.\n",
777 ax->dev->name);
778 break;
779 case 1:
780 ax->crcmode = CRC_MODE_NONE;
781 printk(KERN_INFO "mkiss: %s: crc mode disabled.\n",
782 ax->dev->name);
783 break;
784 case 0:
785 /* fall through */
786 default:
787 crc_force = 0;
788 printk(KERN_INFO "mkiss: %s: crc mode is auto.\n",
789 ax->dev->name);
790 ax->crcmode = CRC_MODE_SMACK_TEST;
791 }
792 ax->crcauto = (crc_force ? 0 : 1);
793
Ralf Baechle815f62b2005-08-24 18:06:36 +0100794 netif_start_queue(dev);
795
796 /* Done. We have linked the TTY line to a channel. */
797 return 0;
798
799out_free_buffers:
800 kfree(ax->rbuff);
801 kfree(ax->xbuff);
802
803out_free_netdev:
804 free_netdev(dev);
805
806out:
807 return err;
808}
809
810static void mkiss_close(struct tty_struct *tty)
811{
812 struct mkiss *ax;
813
814 write_lock(&disc_data_lock);
815 ax = tty->disc_data;
816 tty->disc_data = NULL;
817 write_unlock(&disc_data_lock);
818
Al Viro79ea13c2008-01-24 02:06:46 -0800819 if (!ax)
Ralf Baechle815f62b2005-08-24 18:06:36 +0100820 return;
821
822 /*
823 * We have now ensured that nobody can start using ap from now on, but
824 * we have to wait for all existing users to finish.
825 */
826 if (!atomic_dec_and_test(&ax->refcnt))
827 down(&ax->dead_sem);
828
829 unregister_netdev(ax->dev);
830
831 /* Free all AX25 frame buffers. */
832 kfree(ax->rbuff);
833 kfree(ax->xbuff);
834
835 ax->tty = NULL;
836}
837
838/* Perform I/O control on an active ax25 channel. */
839static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
840 unsigned int cmd, unsigned long arg)
841{
842 struct mkiss *ax = mkiss_get(tty);
Julia Lawallf40e0632008-12-16 15:43:29 -0800843 struct net_device *dev;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100844 unsigned int tmp, err;
845
846 /* First make sure we're connected. */
847 if (ax == NULL)
848 return -ENXIO;
Julia Lawallf40e0632008-12-16 15:43:29 -0800849 dev = ax->dev;
Ralf Baechle815f62b2005-08-24 18:06:36 +0100850
851 switch (cmd) {
852 case SIOCGIFNAME:
853 err = copy_to_user((void __user *) arg, ax->dev->name,
854 strlen(ax->dev->name) + 1) ? -EFAULT : 0;
855 break;
856
857 case SIOCGIFENCAP:
858 err = put_user(4, (int __user *) arg);
859 break;
860
861 case SIOCSIFENCAP:
862 if (get_user(tmp, (int __user *) arg)) {
863 err = -EFAULT;
864 break;
865 }
866
867 ax->mode = tmp;
868 dev->addr_len = AX25_ADDR_LEN;
869 dev->hard_header_len = AX25_KISS_HEADER_LEN +
870 AX25_MAX_HEADER_LEN + 3;
871 dev->type = ARPHRD_AX25;
872
873 err = 0;
874 break;
875
876 case SIOCSIFHWADDR: {
877 char addr[AX25_ADDR_LEN];
Ralf Baechle815f62b2005-08-24 18:06:36 +0100878
879 if (copy_from_user(&addr,
880 (void __user *) arg, AX25_ADDR_LEN)) {
881 err = -EFAULT;
882 break;
883 }
884
Herbert Xu932ff272006-06-09 12:20:56 -0700885 netif_tx_lock_bh(dev);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100886 memcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
Herbert Xu932ff272006-06-09 12:20:56 -0700887 netif_tx_unlock_bh(dev);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100888
889 err = 0;
890 break;
891 }
892 default:
893 err = -ENOIOCTLCMD;
894 }
895
896 mkiss_put(ax);
897
898 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899}
900
901/*
902 * Handle the 'receiver data ready' interrupt.
903 * This function is called by the 'tty_io' module in the kernel when
904 * a block of data has been received, which can now be decapsulated
905 * and sent on to the AX.25 layer for further processing.
906 */
Ralf Baechle815f62b2005-08-24 18:06:36 +0100907static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
908 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100910 struct mkiss *ax = mkiss_get(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
Ralf Baechle815f62b2005-08-24 18:06:36 +0100912 if (!ax)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 return;
914
915 /*
916 * Argh! mtu change time! - costs us the packet part received
917 * at the change
918 */
919 if (ax->mtu != ax->dev->mtu + 73)
920 ax_changedmtu(ax);
921
922 /* Read the characters out of the buffer */
923 while (count--) {
924 if (fp != NULL && *fp++) {
925 if (!test_and_set_bit(AXF_ERROR, &ax->flags))
Stephen Hemmingerddbe9a62009-01-09 13:01:40 +0000926 ax->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 cp++;
928 continue;
929 }
930
931 kiss_unesc(ax, *cp++);
932 }
Ralf Baechle815f62b2005-08-24 18:06:36 +0100933
934 mkiss_put(ax);
Alan Cox39c2e602008-04-30 00:54:18 -0700935 tty_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936}
937
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938/*
Ralf Baechle815f62b2005-08-24 18:06:36 +0100939 * Called by the driver when there's room for more data. If we have
940 * more packets to send, we send them here.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 */
Ralf Baechle815f62b2005-08-24 18:06:36 +0100942static void mkiss_write_wakeup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943{
Ralf Baechle815f62b2005-08-24 18:06:36 +0100944 struct mkiss *ax = mkiss_get(tty);
945 int actual;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Ralf Baechle815f62b2005-08-24 18:06:36 +0100947 if (!ax)
948 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
Ralf Baechle815f62b2005-08-24 18:06:36 +0100950 if (ax->xleft <= 0) {
951 /* Now serial buffer is almost free & we can start
952 * transmission of another packet
953 */
954 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Ralf Baechle815f62b2005-08-24 18:06:36 +0100956 netif_wake_queue(ax->dev);
957 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 }
959
Alan Coxf34d7a52008-04-30 00:54:13 -0700960 actual = tty->ops->write(tty, ax->xhead, ax->xleft);
Ralf Baechle815f62b2005-08-24 18:06:36 +0100961 ax->xleft -= actual;
962 ax->xhead += actual;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Ralf Baechle815f62b2005-08-24 18:06:36 +0100964out:
965 mkiss_put(ax);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966}
967
Alan Coxa352def2008-07-16 21:53:12 +0100968static struct tty_ldisc_ops ax_ldisc = {
Ralf Baechle74cfe032005-10-12 23:11:01 +0100969 .owner = THIS_MODULE,
Ralf Baechle815f62b2005-08-24 18:06:36 +0100970 .magic = TTY_LDISC_MAGIC,
971 .name = "mkiss",
972 .open = mkiss_open,
973 .close = mkiss_close,
974 .ioctl = mkiss_ioctl,
975 .receive_buf = mkiss_receive_buf,
Ralf Baechle815f62b2005-08-24 18:06:36 +0100976 .write_wakeup = mkiss_write_wakeup
977};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
Hannes Edereb33ae22009-02-14 11:33:21 +0000979static const char banner[] __initdata = KERN_INFO \
Ralf Baechle815f62b2005-08-24 18:06:36 +0100980 "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
Hannes Edereb33ae22009-02-14 11:33:21 +0000981static const char msg_regfail[] __initdata = KERN_ERR \
Ralf Baechle815f62b2005-08-24 18:06:36 +0100982 "mkiss: can't register line discipline (err = %d)\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984static int __init mkiss_init_driver(void)
985{
986 int status;
987
988 printk(banner);
989
Hannes Edereb33ae22009-02-14 11:33:21 +0000990 status = tty_register_ldisc(N_AX25, &ax_ldisc);
991 if (status != 0)
992 printk(msg_regfail, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return status;
995}
996
Ralf Baechle815f62b2005-08-24 18:06:36 +0100997static const char msg_unregfail[] __exitdata = KERN_ERR \
998 "mkiss: can't unregister line discipline (err = %d)\n";
999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000static void __exit mkiss_exit_driver(void)
1001{
Ralf Baechle815f62b2005-08-24 18:06:36 +01001002 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Ralf Baechle815f62b2005-08-24 18:06:36 +01001004 if ((ret = tty_unregister_ldisc(N_AX25)))
1005 printk(msg_unregfail, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006}
1007
Ralf Baechle815f62b2005-08-24 18:06:36 +01001008MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
Rusty Russell8d3b33f2006-03-25 03:07:05 -08001010module_param(crc_force, int, 0);
Ralf Baechle5793f4b2005-10-14 14:28:09 +01001011MODULE_PARM_DESC(crc_force, "crc [0 = auto | 1 = none | 2 = flexnet | 3 = smack]");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012MODULE_LICENSE("GPL");
1013MODULE_ALIAS_LDISC(N_AX25);
Ralf Baechle815f62b2005-08-24 18:06:36 +01001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015module_init(mkiss_init_driver);
1016module_exit(mkiss_exit_driver);