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 */ 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/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 #ifdef CONFIG_INET 43 #include <linux/ip.h> 44 #include <linux/tcp.h> 45 #endif 46 47 #define AX_MTU 236 48 49 /* SLIP/KISS protocol characters. */ 50 #define END 0300 /* indicates end of frame */ 51 #define ESC 0333 /* indicates byte stuffing */ 52 #define ESC_END 0334 /* ESC ESC_END means END 'data' */ 53 #define ESC_ESC 0335 /* ESC ESC_ESC means ESC 'data' */ 54 55 struct mkiss { 56 struct tty_struct *tty; /* ptr to TTY structure */ 57 struct net_device *dev; /* easy for intr handling */ 58 59 /* These are pointers to the malloc()ed frame buffers. */ 60 spinlock_t buflock;/* lock for rbuf and xbuf */ 61 unsigned char *rbuff; /* receiver buffer */ 62 int rcount; /* received chars counter */ 63 unsigned char *xbuff; /* transmitter buffer */ 64 unsigned char *xhead; /* pointer to next byte to XMIT */ 65 int xleft; /* bytes left in XMIT queue */ 66 67 struct net_device_stats stats; 68 69 /* Detailed SLIP statistics. */ 70 int mtu; /* Our mtu (to spot changes!) */ 71 int buffsize; /* Max buffers sizes */ 72 73 unsigned long flags; /* Flag values/ mode etc */ 74 /* long req'd: used by set_bit --RR */ 75 #define AXF_INUSE 0 /* Channel in use */ 76 #define AXF_ESCAPE 1 /* ESC received */ 77 #define AXF_ERROR 2 /* Parity, etc. error */ 78 #define AXF_KEEPTEST 3 /* Keepalive test flag */ 79 #define AXF_OUTWAIT 4 /* is outpacket was flag */ 80 81 int mode; 82 int crcmode; /* MW: for FlexNet, SMACK etc. */ 83 #define CRC_MODE_NONE 0 84 #define CRC_MODE_FLEX 1 85 #define CRC_MODE_SMACK 2 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 /* 155 * Standard encapsulation 156 */ 157 158 static int kiss_esc(unsigned char *s, unsigned char *d, int len) 159 { 160 unsigned char *ptr = d; 161 unsigned char c; 162 163 /* 164 * Send an initial END character to flush out any data that may have 165 * accumulated in the receiver due to line noise. 166 */ 167 168 *ptr++ = END; 169 170 while (len-- > 0) { 171 switch (c = *s++) { 172 case END: 173 *ptr++ = ESC; 174 *ptr++ = ESC_END; 175 break; 176 case ESC: 177 *ptr++ = ESC; 178 *ptr++ = ESC_ESC; 179 break; 180 default: 181 *ptr++ = c; 182 break; 183 } 184 } 185 186 *ptr++ = END; 187 188 return ptr - d; 189 } 190 191 /* 192 * MW: 193 * OK its ugly, but tell me a better solution without copying the 194 * packet to a temporary buffer :-) 195 */ 196 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, 197 int len) 198 { 199 unsigned char *ptr = d; 200 unsigned char c=0; 201 202 *ptr++ = END; 203 while (len > 0) { 204 if (len > 2) 205 c = *s++; 206 else if (len > 1) 207 c = crc >> 8; 208 else if (len > 0) 209 c = crc & 0xff; 210 211 len--; 212 213 switch (c) { 214 case END: 215 *ptr++ = ESC; 216 *ptr++ = ESC_END; 217 break; 218 case ESC: 219 *ptr++ = ESC; 220 *ptr++ = ESC_ESC; 221 break; 222 default: 223 *ptr++ = c; 224 break; 225 } 226 } 227 *ptr++ = END; 228 229 return ptr - d; 230 } 231 232 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */ 233 static void ax_bump(struct mkiss *ax) 234 { 235 struct sk_buff *skb; 236 int count; 237 238 spin_lock_bh(&ax->buflock); 239 if (ax->rbuff[0] > 0x0f) { 240 if (ax->rbuff[0] & 0x20) { 241 ax->crcmode = CRC_MODE_FLEX; 242 if (check_crc_flex(ax->rbuff, ax->rcount) < 0) { 243 ax->stats.rx_errors++; 244 return; 245 } 246 ax->rcount -= 2; 247 /* dl9sau bugfix: the trailling two bytes flexnet crc 248 * will not be passed to the kernel. thus we have 249 * to correct the kissparm signature, because it 250 * indicates a crc but there's none 251 */ 252 *ax->rbuff &= ~0x20; 253 } 254 } 255 spin_unlock_bh(&ax->buflock); 256 257 count = ax->rcount; 258 259 if ((skb = dev_alloc_skb(count)) == NULL) { 260 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n", 261 ax->dev->name); 262 ax->stats.rx_dropped++; 263 return; 264 } 265 266 spin_lock_bh(&ax->buflock); 267 memcpy(skb_put(skb,count), ax->rbuff, count); 268 spin_unlock_bh(&ax->buflock); 269 skb->protocol = ax25_type_trans(skb, ax->dev); 270 netif_rx(skb); 271 ax->dev->last_rx = jiffies; 272 ax->stats.rx_packets++; 273 ax->stats.rx_bytes += count; 274 } 275 276 static void kiss_unesc(struct mkiss *ax, unsigned char s) 277 { 278 switch (s) { 279 case END: 280 /* drop keeptest bit = VSV */ 281 if (test_bit(AXF_KEEPTEST, &ax->flags)) 282 clear_bit(AXF_KEEPTEST, &ax->flags); 283 284 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2)) 285 ax_bump(ax); 286 287 clear_bit(AXF_ESCAPE, &ax->flags); 288 ax->rcount = 0; 289 return; 290 291 case ESC: 292 set_bit(AXF_ESCAPE, &ax->flags); 293 return; 294 case ESC_ESC: 295 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags)) 296 s = ESC; 297 break; 298 case ESC_END: 299 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags)) 300 s = END; 301 break; 302 } 303 304 spin_lock_bh(&ax->buflock); 305 if (!test_bit(AXF_ERROR, &ax->flags)) { 306 if (ax->rcount < ax->buffsize) { 307 ax->rbuff[ax->rcount++] = s; 308 spin_unlock_bh(&ax->buflock); 309 return; 310 } 311 312 ax->stats.rx_over_errors++; 313 set_bit(AXF_ERROR, &ax->flags); 314 } 315 spin_unlock_bh(&ax->buflock); 316 } 317 318 static int ax_set_mac_address(struct net_device *dev, void *addr) 319 { 320 struct sockaddr_ax25 *sa = addr; 321 322 spin_lock_irq(&dev->xmit_lock); 323 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN); 324 spin_unlock_irq(&dev->xmit_lock); 325 326 return 0; 327 } 328 329 /*---------------------------------------------------------------------------*/ 330 331 static void ax_changedmtu(struct mkiss *ax) 332 { 333 struct net_device *dev = ax->dev; 334 unsigned char *xbuff, *rbuff, *oxbuff, *orbuff; 335 int len; 336 337 len = dev->mtu * 2; 338 339 /* 340 * allow for arrival of larger UDP packets, even if we say not to 341 * also fixes a bug in which SunOS sends 512-byte packets even with 342 * an MSS of 128 343 */ 344 if (len < 576 * 2) 345 len = 576 * 2; 346 347 xbuff = kmalloc(len + 4, GFP_ATOMIC); 348 rbuff = kmalloc(len + 4, GFP_ATOMIC); 349 350 if (xbuff == NULL || rbuff == NULL) { 351 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, " 352 "MTU change cancelled.\n", 353 ax->dev->name); 354 dev->mtu = ax->mtu; 355 if (xbuff != NULL) 356 kfree(xbuff); 357 if (rbuff != NULL) 358 kfree(rbuff); 359 return; 360 } 361 362 spin_lock_bh(&ax->buflock); 363 364 oxbuff = ax->xbuff; 365 ax->xbuff = xbuff; 366 orbuff = ax->rbuff; 367 ax->rbuff = rbuff; 368 369 if (ax->xleft) { 370 if (ax->xleft <= len) { 371 memcpy(ax->xbuff, ax->xhead, ax->xleft); 372 } else { 373 ax->xleft = 0; 374 ax->stats.tx_dropped++; 375 } 376 } 377 378 ax->xhead = ax->xbuff; 379 380 if (ax->rcount) { 381 if (ax->rcount <= len) { 382 memcpy(ax->rbuff, orbuff, ax->rcount); 383 } else { 384 ax->rcount = 0; 385 ax->stats.rx_over_errors++; 386 set_bit(AXF_ERROR, &ax->flags); 387 } 388 } 389 390 ax->mtu = dev->mtu + 73; 391 ax->buffsize = len; 392 393 spin_unlock_bh(&ax->buflock); 394 395 kfree(oxbuff); 396 kfree(orbuff); 397 } 398 399 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */ 400 static void ax_encaps(struct net_device *dev, unsigned char *icp, int len) 401 { 402 struct mkiss *ax = netdev_priv(dev); 403 unsigned char *p; 404 int actual, count; 405 406 if (ax->mtu != ax->dev->mtu + 73) /* Someone has been ifconfigging */ 407 ax_changedmtu(ax); 408 409 if (len > ax->mtu) { /* Sigh, shouldn't occur BUT ... */ 410 len = ax->mtu; 411 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name); 412 ax->stats.tx_dropped++; 413 netif_start_queue(dev); 414 return; 415 } 416 417 p = icp; 418 419 spin_lock_bh(&ax->buflock); 420 switch (ax->crcmode) { 421 unsigned short crc; 422 423 case CRC_MODE_FLEX: 424 *p |= 0x20; 425 crc = calc_crc_flex(p, len); 426 count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2); 427 break; 428 429 default: 430 count = kiss_esc(p, (unsigned char *)ax->xbuff, len); 431 break; 432 } 433 434 set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags); 435 actual = ax->tty->driver->write(ax->tty, ax->xbuff, count); 436 ax->stats.tx_packets++; 437 ax->stats.tx_bytes += actual; 438 439 ax->dev->trans_start = jiffies; 440 ax->xleft = count - actual; 441 ax->xhead = ax->xbuff + actual; 442 443 spin_unlock_bh(&ax->buflock); 444 } 445 446 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */ 447 static int ax_xmit(struct sk_buff *skb, struct net_device *dev) 448 { 449 struct mkiss *ax = netdev_priv(dev); 450 451 if (!netif_running(dev)) { 452 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name); 453 return 1; 454 } 455 456 if (netif_queue_stopped(dev)) { 457 /* 458 * May be we must check transmitter timeout here ? 459 * 14 Oct 1994 Dmitry Gorodchanin. 460 */ 461 if (time_before(jiffies, dev->trans_start + 20 * HZ)) { 462 /* 20 sec timeout not reached */ 463 return 1; 464 } 465 466 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name, 467 (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ? 468 "bad line quality" : "driver error"); 469 470 ax->xleft = 0; 471 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags); 472 netif_start_queue(dev); 473 } 474 475 /* We were not busy, so we are now... :-) */ 476 if (skb != NULL) { 477 netif_stop_queue(dev); 478 ax_encaps(dev, skb->data, skb->len); 479 kfree_skb(skb); 480 } 481 482 return 0; 483 } 484 485 static int ax_open_dev(struct net_device *dev) 486 { 487 struct mkiss *ax = netdev_priv(dev); 488 489 if (ax->tty == NULL) 490 return -ENODEV; 491 492 return 0; 493 } 494 495 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 496 497 /* Return the frame type ID */ 498 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, 499 void *daddr, void *saddr, unsigned len) 500 { 501 #ifdef CONFIG_INET 502 if (type != htons(ETH_P_AX25)) 503 return ax25_hard_header(skb, dev, type, daddr, saddr, len); 504 #endif 505 return 0; 506 } 507 508 509 static int ax_rebuild_header(struct sk_buff *skb) 510 { 511 #ifdef CONFIG_INET 512 return ax25_rebuild_header(skb); 513 #else 514 return 0; 515 #endif 516 } 517 518 #endif /* CONFIG_{AX25,AX25_MODULE} */ 519 520 /* Open the low-level part of the AX25 channel. Easy! */ 521 static int ax_open(struct net_device *dev) 522 { 523 struct mkiss *ax = netdev_priv(dev); 524 unsigned long len; 525 526 if (ax->tty == NULL) 527 return -ENODEV; 528 529 /* 530 * Allocate the frame buffers: 531 * 532 * rbuff Receive buffer. 533 * xbuff Transmit buffer. 534 */ 535 len = dev->mtu * 2; 536 537 /* 538 * allow for arrival of larger UDP packets, even if we say not to 539 * also fixes a bug in which SunOS sends 512-byte packets even with 540 * an MSS of 128 541 */ 542 if (len < 576 * 2) 543 len = 576 * 2; 544 545 if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL) 546 goto norbuff; 547 548 if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL) 549 goto noxbuff; 550 551 ax->mtu = dev->mtu + 73; 552 ax->buffsize = len; 553 ax->rcount = 0; 554 ax->xleft = 0; 555 556 ax->flags &= (1 << AXF_INUSE); /* Clear ESCAPE & ERROR flags */ 557 558 spin_lock_init(&ax->buflock); 559 560 return 0; 561 562 noxbuff: 563 kfree(ax->rbuff); 564 565 norbuff: 566 return -ENOMEM; 567 } 568 569 570 /* Close the low-level part of the AX25 channel. Easy! */ 571 static int ax_close(struct net_device *dev) 572 { 573 struct mkiss *ax = netdev_priv(dev); 574 575 if (ax->tty) 576 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags); 577 578 netif_stop_queue(dev); 579 580 return 0; 581 } 582 583 static struct net_device_stats *ax_get_stats(struct net_device *dev) 584 { 585 struct mkiss *ax = netdev_priv(dev); 586 587 return &ax->stats; 588 } 589 590 static void ax_setup(struct net_device *dev) 591 { 592 static char ax25_bcast[AX25_ADDR_LEN] = 593 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1}; 594 static char ax25_test[AX25_ADDR_LEN] = 595 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1}; 596 597 /* Finish setting up the DEVICE info. */ 598 dev->mtu = AX_MTU; 599 dev->hard_start_xmit = ax_xmit; 600 dev->open = ax_open_dev; 601 dev->stop = ax_close; 602 dev->get_stats = ax_get_stats; 603 dev->set_mac_address = ax_set_mac_address; 604 dev->hard_header_len = 0; 605 dev->addr_len = 0; 606 dev->type = ARPHRD_AX25; 607 dev->tx_queue_len = 10; 608 dev->hard_header = ax_header; 609 dev->rebuild_header = ax_rebuild_header; 610 611 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN); 612 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN); 613 614 dev->flags = IFF_BROADCAST | IFF_MULTICAST; 615 } 616 617 /* 618 * We have a potential race on dereferencing tty->disc_data, because the tty 619 * layer provides no locking at all - thus one cpu could be running 620 * sixpack_receive_buf while another calls sixpack_close, which zeroes 621 * tty->disc_data and frees the memory that sixpack_receive_buf is using. The 622 * best way to fix this is to use a rwlock in the tty struct, but for now we 623 * use a single global rwlock for all ttys in ppp line discipline. 624 */ 625 static rwlock_t disc_data_lock = RW_LOCK_UNLOCKED; 626 627 static struct mkiss *mkiss_get(struct tty_struct *tty) 628 { 629 struct mkiss *ax; 630 631 read_lock(&disc_data_lock); 632 ax = tty->disc_data; 633 if (ax) 634 atomic_inc(&ax->refcnt); 635 read_unlock(&disc_data_lock); 636 637 return ax; 638 } 639 640 static void mkiss_put(struct mkiss *ax) 641 { 642 if (atomic_dec_and_test(&ax->refcnt)) 643 up(&ax->dead_sem); 644 } 645 646 static int mkiss_open(struct tty_struct *tty) 647 { 648 struct net_device *dev; 649 struct mkiss *ax; 650 int err; 651 652 if (!capable(CAP_NET_ADMIN)) 653 return -EPERM; 654 655 dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup); 656 if (!dev) { 657 err = -ENOMEM; 658 goto out; 659 } 660 661 ax = netdev_priv(dev); 662 ax->dev = dev; 663 664 spin_lock_init(&ax->buflock); 665 atomic_set(&ax->refcnt, 1); 666 init_MUTEX_LOCKED(&ax->dead_sem); 667 668 ax->tty = tty; 669 tty->disc_data = ax; 670 671 if (tty->driver->flush_buffer) 672 tty->driver->flush_buffer(tty); 673 674 /* Restore default settings */ 675 dev->type = ARPHRD_AX25; 676 677 /* Perform the low-level AX25 initialization. */ 678 if ((err = ax_open(ax->dev))) { 679 goto out_free_netdev; 680 } 681 682 if (register_netdev(dev)) 683 goto out_free_buffers; 684 685 netif_start_queue(dev); 686 687 /* Done. We have linked the TTY line to a channel. */ 688 return 0; 689 690 out_free_buffers: 691 kfree(ax->rbuff); 692 kfree(ax->xbuff); 693 694 out_free_netdev: 695 free_netdev(dev); 696 697 out: 698 return err; 699 } 700 701 static void mkiss_close(struct tty_struct *tty) 702 { 703 struct mkiss *ax; 704 705 write_lock(&disc_data_lock); 706 ax = tty->disc_data; 707 tty->disc_data = NULL; 708 write_unlock(&disc_data_lock); 709 710 if (ax == 0) 711 return; 712 713 /* 714 * We have now ensured that nobody can start using ap from now on, but 715 * we have to wait for all existing users to finish. 716 */ 717 if (!atomic_dec_and_test(&ax->refcnt)) 718 down(&ax->dead_sem); 719 720 unregister_netdev(ax->dev); 721 722 /* Free all AX25 frame buffers. */ 723 kfree(ax->rbuff); 724 kfree(ax->xbuff); 725 726 ax->tty = NULL; 727 } 728 729 /* Perform I/O control on an active ax25 channel. */ 730 static int mkiss_ioctl(struct tty_struct *tty, struct file *file, 731 unsigned int cmd, unsigned long arg) 732 { 733 struct mkiss *ax = mkiss_get(tty); 734 struct net_device *dev = ax->dev; 735 unsigned int tmp, err; 736 737 /* First make sure we're connected. */ 738 if (ax == NULL) 739 return -ENXIO; 740 741 switch (cmd) { 742 case SIOCGIFNAME: 743 err = copy_to_user((void __user *) arg, ax->dev->name, 744 strlen(ax->dev->name) + 1) ? -EFAULT : 0; 745 break; 746 747 case SIOCGIFENCAP: 748 err = put_user(4, (int __user *) arg); 749 break; 750 751 case SIOCSIFENCAP: 752 if (get_user(tmp, (int __user *) arg)) { 753 err = -EFAULT; 754 break; 755 } 756 757 ax->mode = tmp; 758 dev->addr_len = AX25_ADDR_LEN; 759 dev->hard_header_len = AX25_KISS_HEADER_LEN + 760 AX25_MAX_HEADER_LEN + 3; 761 dev->type = ARPHRD_AX25; 762 763 err = 0; 764 break; 765 766 case SIOCSIFHWADDR: { 767 char addr[AX25_ADDR_LEN]; 768 printk(KERN_INFO "In SIOCSIFHWADDR"); 769 770 if (copy_from_user(&addr, 771 (void __user *) arg, AX25_ADDR_LEN)) { 772 err = -EFAULT; 773 break; 774 } 775 776 spin_lock_irq(&dev->xmit_lock); 777 memcpy(dev->dev_addr, addr, AX25_ADDR_LEN); 778 spin_unlock_irq(&dev->xmit_lock); 779 780 err = 0; 781 break; 782 } 783 default: 784 err = -ENOIOCTLCMD; 785 } 786 787 mkiss_put(ax); 788 789 return err; 790 } 791 792 /* 793 * Handle the 'receiver data ready' interrupt. 794 * This function is called by the 'tty_io' module in the kernel when 795 * a block of data has been received, which can now be decapsulated 796 * and sent on to the AX.25 layer for further processing. 797 */ 798 static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp, 799 char *fp, int count) 800 { 801 struct mkiss *ax = mkiss_get(tty); 802 803 if (!ax) 804 return; 805 806 /* 807 * Argh! mtu change time! - costs us the packet part received 808 * at the change 809 */ 810 if (ax->mtu != ax->dev->mtu + 73) 811 ax_changedmtu(ax); 812 813 /* Read the characters out of the buffer */ 814 while (count--) { 815 if (fp != NULL && *fp++) { 816 if (!test_and_set_bit(AXF_ERROR, &ax->flags)) 817 ax->stats.rx_errors++; 818 cp++; 819 continue; 820 } 821 822 kiss_unesc(ax, *cp++); 823 } 824 825 mkiss_put(ax); 826 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) 827 && tty->driver->unthrottle) 828 tty->driver->unthrottle(tty); 829 } 830 831 static int mkiss_receive_room(struct tty_struct *tty) 832 { 833 return 65536; /* We can handle an infinite amount of data. :-) */ 834 } 835 836 /* 837 * Called by the driver when there's room for more data. If we have 838 * more packets to send, we send them here. 839 */ 840 static void mkiss_write_wakeup(struct tty_struct *tty) 841 { 842 struct mkiss *ax = mkiss_get(tty); 843 int actual; 844 845 if (!ax) 846 return; 847 848 if (ax->xleft <= 0) { 849 /* Now serial buffer is almost free & we can start 850 * transmission of another packet 851 */ 852 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 853 854 netif_wake_queue(ax->dev); 855 goto out; 856 } 857 858 actual = tty->driver->write(tty, ax->xhead, ax->xleft); 859 ax->xleft -= actual; 860 ax->xhead += actual; 861 862 out: 863 mkiss_put(ax); 864 } 865 866 static struct tty_ldisc ax_ldisc = { 867 .magic = TTY_LDISC_MAGIC, 868 .name = "mkiss", 869 .open = mkiss_open, 870 .close = mkiss_close, 871 .ioctl = mkiss_ioctl, 872 .receive_buf = mkiss_receive_buf, 873 .receive_room = mkiss_receive_room, 874 .write_wakeup = mkiss_write_wakeup 875 }; 876 877 static char banner[] __initdata = KERN_INFO \ 878 "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n"; 879 static char msg_regfail[] __initdata = KERN_ERR \ 880 "mkiss: can't register line discipline (err = %d)\n"; 881 882 static int __init mkiss_init_driver(void) 883 { 884 int status; 885 886 printk(banner); 887 888 if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) 889 printk(msg_regfail); 890 891 return status; 892 } 893 894 static const char msg_unregfail[] __exitdata = KERN_ERR \ 895 "mkiss: can't unregister line discipline (err = %d)\n"; 896 897 static void __exit mkiss_exit_driver(void) 898 { 899 int ret; 900 901 if ((ret = tty_unregister_ldisc(N_AX25))) 902 printk(msg_unregfail, ret); 903 } 904 905 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>"); 906 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs"); 907 MODULE_LICENSE("GPL"); 908 MODULE_ALIAS_LDISC(N_AX25); 909 910 module_init(mkiss_init_driver); 911 module_exit(mkiss_exit_driver); 912