开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mkiss.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：25k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

mkiss.c：源码内容
  1. /*
  2.  * MKISS Driver
  3.  *
  4.  * This module:
  5.  * This module is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version
  8.  * 2 of the License, or (at your option) any later version.
  9.  *
  10.  *  This module implements the AX.25 protocol for kernel-based
  11.  * devices like TTYs. It interfaces between a raw TTY, and the
  12.  * kernel's AX.25 protocol layers, just like slip.c.
  13.  * AX.25 needs to be separated from slip.c while slip.c is no
  14.  * longer a static kernel device since it is a module.
  15.  * This method clears the way to implement other kiss protocols
  16.  * like mkiss smack g8bpq ..... so far only mkiss is implemented.
  17.  *
  18.  * Hans Alblas <hans@esrac.ele.tue.nl>
  19.  *
  20.  * History
  21.  * Jonathan (G4KLX) Fixed to match Linux networking changes - 2.1.15.
  22.  * Matthias (DG2FEF)       Added support for FlexNet CRC (on special request)
  23.  *                              Fixed bug in ax25_close(): dev_lock_wait() was
  24.  *                              called twice, causing a deadlock.
  25.  */
  27. #include <linux/config.h>
  28. #include <linux/module.h>
  29. #include <asm/system.h>
  30. #include <asm/segment.h>
  31. #include <asm/bitops.h>
  32. #include <asm/uaccess.h>
  33. #include <linux/string.h>
  34. #include <linux/mm.h>
  35. #include <linux/interrupt.h>
  36. #include <linux/in.h>
  37. #include <linux/inet.h>
  38. #include <linux/tty.h>
  39. #include <linux/errno.h>
  40. #include <linux/netdevice.h>
  41. #include <linux/major.h>
  42. #include <linux/init.h>
  43. #include <linux/rtnetlink.h>
  44. #include <linux/etherdevice.h>
  45. #include <linux/skbuff.h>
  46. #include <linux/if_arp.h>
  48. #include <net/ax25.h>
  50. #include "mkiss.h"
  52. #ifdef CONFIG_INET
  53. #include <linux/ip.h>
  54. #include <linux/tcp.h>
  55. #endif
  57. static char banner[] __initdata = KERN_INFO "mkiss: AX.25 Multikiss, Hans Albas PE1AYXn";
  59. #define NR_MKISS 4
  60. #define MKISS_SERIAL_TYPE_NORMAL 1
  62. struct mkiss_channel {
  63. int magic; /* magic word */
  64. int init; /* channel exists? */
  65. struct tty_struct *tty; /* link to tty control structure */
  66. };
  68. typedef struct ax25_ctrl {
  69. struct ax_disp ctrl; /*  */
  70. struct net_device  dev; /* the device */
  71. } ax25_ctrl_t;
  73. static ax25_ctrl_t **ax25_ctrls;
  75. int ax25_maxdev = AX25_MAXDEV; /* Can be overridden with insmod! */
  77. static struct tty_ldisc ax_ldisc;
  79. static int ax25_init(struct net_device *);
  80. static int kiss_esc(unsigned char *, unsigned char *, int);
  81. static int kiss_esc_crc(unsigned char *, unsigned char *, unsigned short, int);
  82. static void kiss_unesc(struct ax_disp *, unsigned char);
  84. /*---------------------------------------------------------------------------*/
  86. static const unsigned short Crc_flex_table[] = {
  87.   0x0f87, 0x1e0e, 0x2c95, 0x3d1c, 0x49a3, 0x582a, 0x6ab1, 0x7b38,
  88.   0x83cf, 0x9246, 0xa0dd, 0xb154, 0xc5eb, 0xd462, 0xe6f9, 0xf770,
  89.   0x1f06, 0x0e8f, 0x3c14, 0x2d9d, 0x5922, 0x48ab, 0x7a30, 0x6bb9,
  90.   0x934e, 0x82c7, 0xb05c, 0xa1d5, 0xd56a, 0xc4e3, 0xf678, 0xe7f1,
  91.   0x2e85, 0x3f0c, 0x0d97, 0x1c1e, 0x68a1, 0x7928, 0x4bb3, 0x5a3a,
  92.   0xa2cd, 0xb344, 0x81df, 0x9056, 0xe4e9, 0xf560, 0xc7fb, 0xd672,
  93.   0x3e04, 0x2f8d, 0x1d16, 0x0c9f, 0x7820, 0x69a9, 0x5b32, 0x4abb,
  94.   0xb24c, 0xa3c5, 0x915e, 0x80d7, 0xf468, 0xe5e1, 0xd77a, 0xc6f3,
  95.   0x4d83, 0x5c0a, 0x6e91, 0x7f18, 0x0ba7, 0x1a2e, 0x28b5, 0x393c,
  96.   0xc1cb, 0xd042, 0xe2d9, 0xf350, 0x87ef, 0x9666, 0xa4fd, 0xb574,
  97.   0x5d02, 0x4c8b, 0x7e10, 0x6f99, 0x1b26, 0x0aaf, 0x3834, 0x29bd,
  98.   0xd14a, 0xc0c3, 0xf258, 0xe3d1, 0x976e, 0x86e7, 0xb47c, 0xa5f5,
  99.   0x6c81, 0x7d08, 0x4f93, 0x5e1a, 0x2aa5, 0x3b2c, 0x09b7, 0x183e,
  100.   0xe0c9, 0xf140, 0xc3db, 0xd252, 0xa6ed, 0xb764, 0x85ff, 0x9476,
  101.   0x7c00, 0x6d89, 0x5f12, 0x4e9b, 0x3a24, 0x2bad, 0x1936, 0x08bf,
  102.   0xf048, 0xe1c1, 0xd35a, 0xc2d3, 0xb66c, 0xa7e5, 0x957e, 0x84f7,
  103.   0x8b8f, 0x9a06, 0xa89d, 0xb914, 0xcdab, 0xdc22, 0xeeb9, 0xff30,
  104.   0x07c7, 0x164e, 0x24d5, 0x355c, 0x41e3, 0x506a, 0x62f1, 0x7378,
  105.   0x9b0e, 0x8a87, 0xb81c, 0xa995, 0xdd2a, 0xcca3, 0xfe38, 0xefb1,
  106.   0x1746, 0x06cf, 0x3454, 0x25dd, 0x5162, 0x40eb, 0x7270, 0x63f9,
  107.   0xaa8d, 0xbb04, 0x899f, 0x9816, 0xeca9, 0xfd20, 0xcfbb, 0xde32,
  108.   0x26c5, 0x374c, 0x05d7, 0x145e, 0x60e1, 0x7168, 0x43f3, 0x527a,
  109.   0xba0c, 0xab85, 0x991e, 0x8897, 0xfc28, 0xeda1, 0xdf3a, 0xceb3,
  110.   0x3644, 0x27cd, 0x1556, 0x04df, 0x7060, 0x61e9, 0x5372, 0x42fb,
  111.   0xc98b, 0xd802, 0xea99, 0xfb10, 0x8faf, 0x9e26, 0xacbd, 0xbd34,
  112.   0x45c3, 0x544a, 0x66d1, 0x7758, 0x03e7, 0x126e, 0x20f5, 0x317c,
  113.   0xd90a, 0xc883, 0xfa18, 0xeb91, 0x9f2e, 0x8ea7, 0xbc3c, 0xadb5,
  114.   0x5542, 0x44cb, 0x7650, 0x67d9, 0x1366, 0x02ef, 0x3074, 0x21fd,
  115.   0xe889, 0xf900, 0xcb9b, 0xda12, 0xaead, 0xbf24, 0x8dbf, 0x9c36,
  116.   0x64c1, 0x7548, 0x47d3, 0x565a, 0x22e5, 0x336c, 0x01f7, 0x107e,
  117.   0xf808, 0xe981, 0xdb1a, 0xca93, 0xbe2c, 0xafa5, 0x9d3e, 0x8cb7,
  118.   0x7440, 0x65c9, 0x5752, 0x46db, 0x3264, 0x23ed, 0x1176, 0x00ff
  119. };
  121. /*---------------------------------------------------------------------------*/
  123. static unsigned short calc_crc_flex(unsigned char *cp, int size)
  124. {
  125.     unsigned short crc = 0xffff;
  126.     
  127.     while (size--)
  128. crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
  130.     return crc;
  131. }
  133. /*---------------------------------------------------------------------------*/
  135. static int check_crc_flex(unsigned char *cp, int size)
  136. {
  137.   unsigned short crc = 0xffff;
  139.   if (size < 3)
  140.       return -1;
  142.   while (size--)
  143.       crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
  145.   if ((crc & 0xffff) != 0x7070) 
  146.       return -1;
  148.   return 0;
  149. }
  151. /*---------------------------------------------------------------------------*/
  153. /* Find a free channel, and link in this `tty' line. */
  154. static inline struct ax_disp *ax_alloc(void)
  155. {
  156. ax25_ctrl_t *axp=NULL;
  157. int i;
  159. for (i = 0; i < ax25_maxdev; i++) {
  160. axp = ax25_ctrls[i];
  162. /* Not allocated ? */
  163. if (axp == NULL)
  164. break;
  166. /* Not in use ? */
  167. if (!test_and_set_bit(AXF_INUSE, &axp->ctrl.flags))
  168. break;
  169. }
  171. /* Sorry, too many, all slots in use */
  172. if (i >= ax25_maxdev)
  173. return NULL;
  175. /* If no channels are available, allocate one */
  176. if (axp == NULL && (ax25_ctrls[i] = kmalloc(sizeof(ax25_ctrl_t), GFP_KERNEL)) != NULL) {
  177. axp = ax25_ctrls[i];
  178. memset(axp, 0, sizeof(ax25_ctrl_t));
  180. /* Initialize channel control data */
  181. set_bit(AXF_INUSE, &axp->ctrl.flags);
  182. sprintf(axp->dev.name, "ax%d", i++);
  183. axp->ctrl.tty      = NULL;
  184. axp->dev.base_addr = i;
  185. axp->dev.priv      = (void *)&axp->ctrl;
  186. axp->dev.next      = NULL;
  187. axp->dev.init      = ax25_init;
  188. }
  190. if (axp != NULL) {
  191. /*
  192.  * register device so that it can be ifconfig'ed
  193.  * ax25_init() will be called as a side-effect
  194.  * SIDE-EFFECT WARNING: ax25_init() CLEARS axp->ctrl !
  195.  */
  196. if (register_netdev(&axp->dev) == 0) {
  197. /* (Re-)Set the INUSE bit.   Very Important! */
  198. set_bit(AXF_INUSE, &axp->ctrl.flags);
  199. axp->ctrl.dev = &axp->dev;
  200. axp->dev.priv = (void *) &axp->ctrl;
  202. return &axp->ctrl;
  203. } else {
  204. clear_bit(AXF_INUSE,&axp->ctrl.flags);
  205. printk(KERN_ERR "mkiss: ax_alloc() - register_netdev() failure.n");
  206. }
  207. }
  209. return NULL;
  210. }
  212. /* Free an AX25 channel. */
  213. static inline void ax_free(struct ax_disp *ax)
  214. {
  215. /* Free all AX25 frame buffers. */
  216. if (ax->rbuff)
  217. kfree(ax->rbuff);
  218. ax->rbuff = NULL;
  219. if (ax->xbuff)
  220. kfree(ax->xbuff);
  221. ax->xbuff = NULL;
  222. if (!test_and_clear_bit(AXF_INUSE, &ax->flags))
  223. printk(KERN_ERR "mkiss: %s: ax_free for already free unit.n", ax->dev->name);
  224. }
  226. static void ax_changedmtu(struct ax_disp *ax)
  227. {
  228. struct net_device *dev = ax->dev;
  229. unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
  230. int len;
  231. unsigned long flags;
  233. len = dev->mtu * 2;
  235. /*
  236.  * allow for arrival of larger UDP packets, even if we say not to
  237.  * also fixes a bug in which SunOS sends 512-byte packets even with
  238.  * an MSS of 128
  239.  */
  240. if (len < 576 * 2)
  241. len = 576 * 2;
  243. xbuff = kmalloc(len + 4, GFP_ATOMIC);
  244. rbuff = kmalloc(len + 4, GFP_ATOMIC);
  246. if (xbuff == NULL || rbuff == NULL)  {
  247. printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, MTU change cancelled.n",
  248.        ax->dev->name);
  249. dev->mtu = ax->mtu;
  250. if (xbuff != NULL)
  251. kfree(xbuff);
  252. if (rbuff != NULL)
  253. kfree(rbuff);
  254. return;
  255. }
  257. save_flags(flags);
  258. cli();
  260. oxbuff    = ax->xbuff;
  261. ax->xbuff = xbuff;
  262. orbuff    = ax->rbuff;
  263. ax->rbuff = rbuff;
  265. if (ax->xleft) {
  266. if (ax->xleft <= len) {
  267. memcpy(ax->xbuff, ax->xhead, ax->xleft);
  268. } else  {
  269. ax->xleft = 0;
  270. ax->tx_dropped++;
  271. }
  272. }
  274. ax->xhead = ax->xbuff;
  276. if (ax->rcount) {
  277. if (ax->rcount <= len) {
  278. memcpy(ax->rbuff, orbuff, ax->rcount);
  279. } else  {
  280. ax->rcount = 0;
  281. ax->rx_over_errors++;
  282. set_bit(AXF_ERROR, &ax->flags);
  283. }
  284. }
  286. ax->mtu      = dev->mtu + 73;
  287. ax->buffsize = len;
  289. restore_flags(flags);
  291. if (oxbuff != NULL)
  292. kfree(oxbuff);
  293. if (orbuff != NULL)
  294. kfree(orbuff);
  295. }
  298. /* Set the "sending" flag.  This must be atomic. */
  299. static inline void ax_lock(struct ax_disp *ax)
  300. {
  301. netif_stop_queue(ax->dev);
  302. }
  305. /* Clear the "sending" flag.  This must be atomic. */
  306. static inline void ax_unlock(struct ax_disp *ax)
  307. {
  308. netif_start_queue(ax->dev);
  309. }
  311. /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
  312. static void ax_bump(struct ax_disp *ax)
  313. {
  314. struct ax_disp *tmp_ax;
  315. struct sk_buff *skb;
  316. struct mkiss_channel *mkiss;
  317. int count;
  319.         tmp_ax = ax;
  321. if (ax->rbuff[0] > 0x0f) {
  322. if (ax->mkiss != NULL) {
  323. mkiss= ax->mkiss->tty->driver_data;
  324. if (mkiss->magic == MKISS_DRIVER_MAGIC)
  325. tmp_ax = ax->mkiss;
  326. } else if (ax->rbuff[0] & 0x20) {
  327.         ax->crcmode = CRC_MODE_FLEX;
  328. if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
  329.         ax->rx_errors++;
  330. return;
  331. }
  332. ax->rcount -= 2;
  333. }
  334.   }
  336. count = ax->rcount;
  338. if ((skb = dev_alloc_skb(count)) == NULL) {
  339. printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.n", ax->dev->name);
  340. ax->rx_dropped++;
  341. return;
  342. }
  344. skb->dev      = tmp_ax->dev;
  345. memcpy(skb_put(skb,count), ax->rbuff, count);
  346. skb->mac.raw  = skb->data;
  347. skb->protocol = htons(ETH_P_AX25);
  348. netif_rx(skb);
  349. tmp_ax->rx_packets++;
  350. }
  352. /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
  353. static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
  354. {
  355. unsigned char *p;
  356. int actual, count;
  357. struct mkiss_channel *mkiss = ax->tty->driver_data;
  359. if (ax->mtu != ax->dev->mtu + 73) /* Someone has been ifconfigging */
  360. ax_changedmtu(ax);
  362. if (len > ax->mtu) { /* Sigh, shouldn't occur BUT ... */
  363. len = ax->mtu;
  364. printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!n", ax->dev->name);
  365. ax->tx_dropped++;
  366. ax_unlock(ax);
  367. return;
  368. }
  370. p = icp;
  372. if (mkiss->magic  != MKISS_DRIVER_MAGIC) {
  373.         switch (ax->crcmode) {
  374.          unsigned short crc;
  376. case CRC_MODE_FLEX:
  377.          *p |= 0x20;
  378.          crc = calc_crc_flex(p, len);
  379.  count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
  380.  break;
  382. default:
  383.          count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
  384.  break;
  385. }
  386. ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  387. actual = ax->tty->driver.write(ax->tty, 0, ax->xbuff, count);
  388. ax->tx_packets++;
  389. ax->dev->trans_start = jiffies;
  390. ax->xleft = count - actual;
  391. ax->xhead = ax->xbuff + actual;
  392. } else {
  393. count = kiss_esc(p, (unsigned char *) ax->mkiss->xbuff, len);
  394. ax->mkiss->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  395. actual = ax->mkiss->tty->driver.write(ax->mkiss->tty, 0, ax->mkiss->xbuff, count);
  396. ax->tx_packets++;
  397. ax->mkiss->dev->trans_start = jiffies;
  398. ax->mkiss->xleft = count - actual;
  399. ax->mkiss->xhead = ax->mkiss->xbuff + actual;
  400. }
  401. }
  403. /*
  404.  * Called by the driver when there's room for more data.  If we have
  405.  * more packets to send, we send them here.
  406.  */
  407. static void ax25_write_wakeup(struct tty_struct *tty)
  408. {
  409. int actual;
  410. struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
  411. struct mkiss_channel *mkiss;
  413. /* First make sure we're connected. */
  414. if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
  415. return;
  416. if (ax->xleft <= 0)  {
  417. /* Now serial buffer is almost free & we can start
  418.  * transmission of another packet
  419.  */
  420. tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  422. if (ax->mkiss != NULL) {
  423. mkiss= ax->mkiss->tty->driver_data;
  424. if (mkiss->magic  == MKISS_DRIVER_MAGIC)
  425. ax_unlock(ax->mkiss);
  426.         }
  428. netif_wake_queue(ax->dev);
  429. return;
  430. }
  432. actual = tty->driver.write(tty, 0, ax->xhead, ax->xleft);
  433. ax->xleft -= actual;
  434. ax->xhead += actual;
  435. }
  437. /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
  438. static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
  439. {
  440. struct ax_disp *ax = (struct ax_disp *) dev->priv;
  441. struct mkiss_channel *mkiss = ax->tty->driver_data;
  442. struct ax_disp *tmp_ax;
  444. tmp_ax = NULL;
  446. if (mkiss->magic  == MKISS_DRIVER_MAGIC) {
  447. if (skb->data[0] < 0x10)
  448. skb->data[0] = skb->data[0] + 0x10;
  449. tmp_ax = ax->mkiss;
  450. }
  452. if (!netif_running(dev))  {
  453. printk(KERN_ERR "mkiss: %s: xmit call when iface is downn", dev->name);
  454. return 1;
  455. }
  457. if (tmp_ax != NULL)
  458. if (netif_queue_stopped(tmp_ax->dev))
  459. return 1;
  461. if (tmp_ax != NULL)
  462. if (netif_queue_stopped(dev)) {
  463. printk(KERN_ERR "mkiss: dev busy while serial dev is freen");
  464. ax_unlock(ax);
  465.         }
  467. if (netif_queue_stopped(dev)) {
  468. /*
  469.  * May be we must check transmitter timeout here ?
  470.  *      14 Oct 1994 Dmitry Gorodchanin.
  471.  */
  472. if (jiffies - dev->trans_start  < 20 * HZ) {
  473. /* 20 sec timeout not reached */
  474. return 1;
  475. }
  477. printk(KERN_ERR "mkiss: %s: transmit timed out, %s?n", dev->name,
  478.        (ax->tty->driver.chars_in_buffer(ax->tty) || ax->xleft) ?
  479.        "bad line quality" : "driver error");
  481. ax->xleft = 0;
  482. ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  483. ax_unlock(ax);
  484. }
  486. /* We were not busy, so we are now... :-) */
  487. if (skb != NULL) {
  488. ax_lock(ax);
  489. if (tmp_ax != NULL)
  490. ax_lock(tmp_ax);
  491. ax_encaps(ax, skb->data, skb->len);
  492. kfree_skb(skb);
  493. }
  495. return 0;
  496. }
  498. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  500. /* Return the frame type ID */
  501. static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
  502.   void *daddr, void *saddr, unsigned len)
  503. {
  504. #ifdef CONFIG_INET
  505. if (type != htons(ETH_P_AX25))
  506. return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
  507. #endif
  508. return 0;
  509. }
  512. static int ax_rebuild_header(struct sk_buff *skb)
  513. {
  514. #ifdef CONFIG_INET
  515. return ax25_rebuild_header(skb);
  516. #else
  517. return 0;
  518. #endif
  519. }
  521. #endif /* CONFIG_{AX25,AX25_MODULE} */
  523. /* Open the low-level part of the AX25 channel. Easy! */
  524. static int ax_open(struct net_device *dev)
  525. {
  526. struct ax_disp *ax = (struct ax_disp *) dev->priv;
  527. unsigned long len;
  529. if (ax->tty == NULL)
  530. return -ENODEV;
  532. /*
  533.  * Allocate the frame buffers:
  534.  *
  535.  * rbuff Receive buffer.
  536.  * xbuff Transmit buffer.
  537.  */
  538. len = dev->mtu * 2;
  540. /*
  541.  * allow for arrival of larger UDP packets, even if we say not to
  542.  * also fixes a bug in which SunOS sends 512-byte packets even with
  543.  * an MSS of 128
  544.  */
  545. if (len < 576 * 2)
  546. len = 576 * 2;
  548. if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
  549. goto norbuff;
  551. if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
  552. goto noxbuff;
  554. ax->mtu      = dev->mtu + 73;
  555. ax->buffsize = len;
  556. ax->rcount   = 0;
  557. ax->xleft    = 0;
  559. ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
  561. netif_start_queue(dev);
  562. return 0;
  564. noxbuff:
  565. kfree(ax->rbuff);
  567. norbuff:
  568. return -ENOMEM;
  569. }
  572. /* Close the low-level part of the AX25 channel. Easy! */
  573. static int ax_close(struct net_device *dev)
  574. {
  575. struct ax_disp *ax = (struct ax_disp *) dev->priv;
  577. if (ax->tty == NULL)
  578. return -EBUSY;
  580. ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  582. netif_stop_queue(dev);
  584. return 0;
  585. }
  587. static int ax25_receive_room(struct tty_struct *tty)
  588. {
  589. return 65536;  /* We can handle an infinite amount of data. :-) */
  590. }
  592. /*
  593.  * Handle the 'receiver data ready' interrupt.
  594.  * This function is called by the 'tty_io' module in the kernel when
  595.  * a block of data has been received, which can now be decapsulated
  596.  * and sent on to the AX.25 layer for further processing.
  597.  */
  598. static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
  599. {
  600. struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
  602. if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
  603. return;
  605. /*
  606.  * Argh! mtu change time! - costs us the packet part received
  607.  * at the change
  608.  */
  609. if (ax->mtu != ax->dev->mtu + 73)
  610. ax_changedmtu(ax);
  612. /* Read the characters out of the buffer */
  613. while (count--) {
  614. if (fp != NULL && *fp++) {
  615. if (!test_and_set_bit(AXF_ERROR, &ax->flags))
  616. ax->rx_errors++;
  617. cp++;
  618. continue;
  619. }
  621. kiss_unesc(ax, *cp++);
  622. }
  623. }
  625. static int ax25_open(struct tty_struct *tty)
  626. {
  627. struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
  628. struct ax_disp *tmp_ax;
  629. struct mkiss_channel *mkiss;
  630. int err, cnt;
  632. /* First make sure we're not already connected. */
  633. if (ax && ax->magic == AX25_MAGIC)
  634. return -EEXIST;
  636. /* OK.  Find a free AX25 channel to use. */
  637. if ((ax = ax_alloc()) == NULL)
  638. return -ENFILE;
  640. ax->tty = tty;
  641. tty->disc_data = ax;
  643. ax->mkiss = NULL;
  644. tmp_ax    = NULL;
  646. if (tty->driver.flush_buffer)
  647. tty->driver.flush_buffer(tty);
  648. if (tty->ldisc.flush_buffer)
  649. tty->ldisc.flush_buffer(tty);
  651. /* Restore default settings */
  652. ax->dev->type = ARPHRD_AX25;
  654. /* Perform the low-level AX25 initialization. */
  655. if ((err = ax_open(ax->dev)))
  656. return err;
  658. mkiss = ax->tty->driver_data;
  660. if (mkiss->magic  == MKISS_DRIVER_MAGIC) {
  661. for (cnt = 1; cnt < ax25_maxdev; cnt++) {
  662. if (ax25_ctrls[cnt]) {
  663. if (netif_running(&ax25_ctrls[cnt]->dev)) {
  664. if (ax == &ax25_ctrls[cnt]->ctrl) {
  665. cnt--;
  666. tmp_ax = &ax25_ctrls[cnt]->ctrl;
  667. break;
  668. }
  669. }
  670. }
  671. }
  672. }
  674. if (tmp_ax != NULL) {
  675. ax->mkiss     = tmp_ax;
  676. tmp_ax->mkiss = ax;
  677. }
  679. MOD_INC_USE_COUNT;
  681. /* Done.  We have linked the TTY line to a channel. */
  682. return ax->dev->base_addr;
  683. }
  685. static void ax25_close(struct tty_struct *tty)
  686. {
  687. struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
  689. /* First make sure we're connected. */
  690. if (ax == NULL || ax->magic != AX25_MAGIC)
  691. return;
  693. unregister_netdev(ax->dev);
  695. tty->disc_data = 0;
  696. ax->tty        = NULL;
  698. ax_free(ax);
  699. MOD_DEC_USE_COUNT;
  700. }
  703. static struct net_device_stats *ax_get_stats(struct net_device *dev)
  704. {
  705. static struct net_device_stats stats;
  706. struct ax_disp *ax = (struct ax_disp *) dev->priv;
  708. memset(&stats, 0, sizeof(struct net_device_stats));
  710. stats.rx_packets     = ax->rx_packets;
  711. stats.tx_packets     = ax->tx_packets;
  712. stats.rx_dropped     = ax->rx_dropped;
  713. stats.tx_dropped     = ax->tx_dropped;
  714. stats.tx_errors      = ax->tx_errors;
  715. stats.rx_errors      = ax->rx_errors;
  716. stats.rx_over_errors = ax->rx_over_errors;
  718. return &stats;
  719. }
  722. /************************************************************************
  723.  *    STANDARD ENCAPSULATION           *
  724.  ************************************************************************/
  726. static int kiss_esc(unsigned char *s, unsigned char *d, int len)
  727. {
  728. unsigned char *ptr = d;
  729. unsigned char c;
  731. /*
  732.  * Send an initial END character to flush out any
  733.  * data that may have accumulated in the receiver
  734.  * due to line noise.
  735.  */
  737. *ptr++ = END;
  739. while (len-- > 0) {
  740. switch (c = *s++) {
  741. case END:
  742. *ptr++ = ESC;
  743. *ptr++ = ESC_END;
  744. break;
  745. case ESC:
  746. *ptr++ = ESC;
  747. *ptr++ = ESC_ESC;
  748. break;
  749. default:
  750. *ptr++ = c;
  751. break;
  752. }
  753. }
  755. *ptr++ = END;
  757. return ptr - d;
  758. }
  760. /*
  761.  * MW:
  762.  * OK its ugly, but tell me a better solution without copying the
  763.  * packet to a temporary buffer :-)
  764.  */
  765. static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
  766. {
  767. unsigned char *ptr = d;
  768. unsigned char c=0;
  770. *ptr++ = END;
  771. while (len > 0) {
  772. if (len > 2) 
  773. c = *s++;
  774. else if (len > 1)
  775. c = crc >> 8;
  776. else if (len > 0)
  777. c = crc & 0xff;
  779. len--;
  781. switch (c) {
  782.                         case END:
  783.                                 *ptr++ = ESC;
  784.                                 *ptr++ = ESC_END;
  785.                                 break;
  786.                         case ESC:
  787.                                 *ptr++ = ESC;
  788.                                 *ptr++ = ESC_ESC;
  789.                                 break;
  790.                         default:
  791.                                 *ptr++ = c;
  792.                                 break;
  793. }
  794. }
  795. *ptr++ = END;
  796. return ptr - d;
  797. }
  799. static void kiss_unesc(struct ax_disp *ax, unsigned char s)
  800. {
  801. switch (s) {
  802. case END:
  803. /* drop keeptest bit = VSV */
  804. if (test_bit(AXF_KEEPTEST, &ax->flags))
  805. clear_bit(AXF_KEEPTEST, &ax->flags);
  807. if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
  808. ax_bump(ax);
  810. clear_bit(AXF_ESCAPE, &ax->flags);
  811. ax->rcount = 0;
  812. return;
  814. case ESC:
  815. set_bit(AXF_ESCAPE, &ax->flags);
  816. return;
  817. case ESC_ESC:
  818. if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
  819. s = ESC;
  820. break;
  821. case ESC_END:
  822. if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
  823. s = END;
  824. break;
  825. }
  827. if (!test_bit(AXF_ERROR, &ax->flags)) {
  828. if (ax->rcount < ax->buffsize) {
  829. ax->rbuff[ax->rcount++] = s;
  830. return;
  831. }
  833. ax->rx_over_errors++;
  834. set_bit(AXF_ERROR, &ax->flags);
  835. }
  836. }
  839. static int ax_set_mac_address(struct net_device *dev, void *addr)
  840. {
  841. if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
  842. return -EFAULT;
  843. return 0;
  844. }
  846. static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
  847. {
  848. struct sockaddr *sa = addr;
  850. memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
  852. return 0;
  853. }
  856. /* Perform I/O control on an active ax25 channel. */
  857. static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
  858. {
  859. struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
  860. unsigned int tmp;
  862. /* First make sure we're connected. */
  863. if (ax == NULL || ax->magic != AX25_MAGIC)
  864. return -EINVAL;
  866. switch (cmd) {
  867.   case SIOCGIFNAME:
  868. if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
  869. return -EFAULT;
  870. return 0;
  872. case SIOCGIFENCAP:
  873. return put_user(4, (int *)arg);
  875. case SIOCSIFENCAP:
  876. if (get_user(tmp, (int *)arg))
  877. return -EFAULT;
  878. ax->mode = tmp;
  879. ax->dev->addr_len        = AX25_ADDR_LEN;   /* sizeof an AX.25 addr */
  880. ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
  881. ax->dev->type            = ARPHRD_AX25;
  882. return 0;
  884.  case SIOCSIFHWADDR:
  885. return ax_set_mac_address(ax->dev, arg);
  887. default:
  888. return -ENOIOCTLCMD;
  889. }
  890. }
  892. static int ax_open_dev(struct net_device *dev)
  893. {
  894. struct ax_disp *ax = (struct ax_disp *) dev->priv;
  896. if (ax->tty == NULL)
  897. return -ENODEV;
  899. return 0;
  900. }
  903. /* Initialize the driver.  Called by network startup. */
  904. static int ax25_init(struct net_device *dev)
  905. {
  906. struct ax_disp *ax = (struct ax_disp *) dev->priv;
  908. static char ax25_bcast[AX25_ADDR_LEN] =
  909. {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
  910. static char ax25_test[AX25_ADDR_LEN] =
  911. {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
  913. if (ax == NULL) /* Allocation failed ?? */
  914. return -ENODEV;
  916. /* Set up the "AX25 Control Block". (And clear statistics) */
  917. memset(ax, 0, sizeof (struct ax_disp));
  918. ax->magic  = AX25_MAGIC;
  919. ax->dev    = dev;
  921. /* Finish setting up the DEVICE info. */
  922. dev->mtu             = AX_MTU;
  923. dev->hard_start_xmit = ax_xmit;
  924. dev->open            = ax_open_dev;
  925. dev->stop            = ax_close;
  926. dev->get_stats      = ax_get_stats;
  927. dev->set_mac_address = ax_set_dev_mac_address;
  928. dev->hard_header_len = 0;
  929. dev->addr_len        = 0;
  930. dev->type            = ARPHRD_AX25;
  931. dev->tx_queue_len    = 10;
  932. dev->hard_header     = ax_header;
  933. dev->rebuild_header  = ax_rebuild_header;
  935. memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
  936. memcpy(dev->dev_addr,  ax25_test,  AX25_ADDR_LEN);
  938. /* New-style flags. */
  939. dev->flags      = 0;
  941. return 0;
  942. }
  945. /* ******************************************************************** */
  946. /* * Init MKISS driver       * */
  947. /* ******************************************************************** */
  949. static int __init mkiss_init_driver(void)
  950. {
  951. int status;
  953. printk(banner);
  955. if (ax25_maxdev < 4)
  956.   ax25_maxdev = 4; /* Sanity */
  958. if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
  959. printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!n");
  960. return -ENOMEM;
  961. }
  963. /* Clear the pointer array, we allocate devices when we need them */
  964. memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
  966. /* Fill in our line protocol discipline, and register it */
  967. ax_ldisc.magic = TTY_LDISC_MAGIC;
  968. ax_ldisc.name = "mkiss";
  969. ax_ldisc.open = ax25_open;
  970. ax_ldisc.close = ax25_close;
  971. ax_ldisc.ioctl = (int (*)(struct tty_struct *, struct file *,
  972. unsigned int, unsigned long))ax25_disp_ioctl;
  973. ax_ldisc.receive_buf = ax25_receive_buf;
  974. ax_ldisc.receive_room = ax25_receive_room;
  975. ax_ldisc.write_wakeup = ax25_write_wakeup;
  977. if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
  978. printk(KERN_ERR "mkiss: can't register line discipline (err = %d)n", status);
  979. kfree(ax25_ctrls);
  980. }
  981. return status;
  982. }
  984. static void __exit mkiss_exit_driver(void)
  985. {
  986. int i;
  988. for (i = 0; i < ax25_maxdev; i++) {
  989. if (ax25_ctrls[i]) {
  990. /*
  991. * VSV = if dev->start==0, then device
  992. * unregistered while close proc.
  993. */
  994. if (netif_running(&ax25_ctrls[i]->dev))
  995. unregister_netdev(&ax25_ctrls[i]->dev);
  996. kfree(ax25_ctrls[i]);
  997. }
  998. }
  1000. kfree(ax25_ctrls);
  1001. ax25_ctrls = NULL;
  1003. if ((i = tty_register_ldisc(N_AX25, NULL)))
  1004. printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)n", i);
  1005. }
  1007. MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
  1008. MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
  1009. MODULE_PARM(ax25_maxdev, "i");
  1010. MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
  1011. MODULE_LICENSE("GPL");
  1013. module_init(mkiss_init_driver);
  1014. module_exit(mkiss_exit_driver);