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