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