projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / hamradio / mkiss.c
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);
kernel source for telekom puls (alcatel/mediatek)