This source file includes following definitions.
- slc_bump
- slcan_unesc
- slc_encaps
- slcan_transmit
- slcan_write_wakeup
- slc_xmit
- slc_close
- slc_open
- slc_free_netdev
- slcan_change_mtu
- slc_setup
- slcan_receive_buf
- slc_sync
- slc_alloc
- slcan_open
- slcan_close
- slcan_hangup
- slcan_ioctl
- slcan_init
- slcan_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38 #include <linux/module.h>
39 #include <linux/moduleparam.h>
40
41 #include <linux/uaccess.h>
42 #include <linux/bitops.h>
43 #include <linux/string.h>
44 #include <linux/tty.h>
45 #include <linux/errno.h>
46 #include <linux/netdevice.h>
47 #include <linux/skbuff.h>
48 #include <linux/rtnetlink.h>
49 #include <linux/if_arp.h>
50 #include <linux/if_ether.h>
51 #include <linux/sched.h>
52 #include <linux/delay.h>
53 #include <linux/init.h>
54 #include <linux/kernel.h>
55 #include <linux/workqueue.h>
56 #include <linux/can.h>
57 #include <linux/can/skb.h>
58 #include <linux/can/can-ml.h>
59
60 MODULE_ALIAS_LDISC(N_SLCAN);
61 MODULE_DESCRIPTION("serial line CAN interface");
62 MODULE_LICENSE("GPL");
63 MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
64
65 #define SLCAN_MAGIC 0x53CA
66
67 static int maxdev = 10;
68
69
70 module_param(maxdev, int, 0);
71 MODULE_PARM_DESC(maxdev, "Maximum number of slcan interfaces");
72
73
74 #define SLC_MTU (sizeof("T1111222281122334455667788EA5F\r")+1)
75
76 #define SLC_CMD_LEN 1
77 #define SLC_SFF_ID_LEN 3
78 #define SLC_EFF_ID_LEN 8
79
80 struct slcan {
81 int magic;
82
83
84 struct tty_struct *tty;
85 struct net_device *dev;
86 spinlock_t lock;
87 struct work_struct tx_work;
88
89
90 unsigned char rbuff[SLC_MTU];
91 int rcount;
92 unsigned char xbuff[SLC_MTU];
93 unsigned char *xhead;
94 int xleft;
95
96 unsigned long flags;
97 #define SLF_INUSE 0
98 #define SLF_ERROR 1
99 };
100
101 static struct net_device **slcan_devs;
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143 static void slc_bump(struct slcan *sl)
144 {
145 struct sk_buff *skb;
146 struct can_frame cf;
147 int i, tmp;
148 u32 tmpid;
149 char *cmd = sl->rbuff;
150
151 memset(&cf, 0, sizeof(cf));
152
153 switch (*cmd) {
154 case 'r':
155 cf.can_id = CAN_RTR_FLAG;
156
157 case 't':
158
159 cf.can_dlc = sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN];
160 sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN] = 0;
161
162 cmd += SLC_CMD_LEN + SLC_SFF_ID_LEN + 1;
163 break;
164 case 'R':
165 cf.can_id = CAN_RTR_FLAG;
166
167 case 'T':
168 cf.can_id |= CAN_EFF_FLAG;
169
170 cf.can_dlc = sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN];
171 sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN] = 0;
172
173 cmd += SLC_CMD_LEN + SLC_EFF_ID_LEN + 1;
174 break;
175 default:
176 return;
177 }
178
179 if (kstrtou32(sl->rbuff + SLC_CMD_LEN, 16, &tmpid))
180 return;
181
182 cf.can_id |= tmpid;
183
184
185 if (cf.can_dlc >= '0' && cf.can_dlc < '9')
186 cf.can_dlc -= '0';
187 else
188 return;
189
190
191 if (!(cf.can_id & CAN_RTR_FLAG)) {
192 for (i = 0; i < cf.can_dlc; i++) {
193 tmp = hex_to_bin(*cmd++);
194 if (tmp < 0)
195 return;
196 cf.data[i] = (tmp << 4);
197 tmp = hex_to_bin(*cmd++);
198 if (tmp < 0)
199 return;
200 cf.data[i] |= tmp;
201 }
202 }
203
204 skb = dev_alloc_skb(sizeof(struct can_frame) +
205 sizeof(struct can_skb_priv));
206 if (!skb)
207 return;
208
209 skb->dev = sl->dev;
210 skb->protocol = htons(ETH_P_CAN);
211 skb->pkt_type = PACKET_BROADCAST;
212 skb->ip_summed = CHECKSUM_UNNECESSARY;
213
214 can_skb_reserve(skb);
215 can_skb_prv(skb)->ifindex = sl->dev->ifindex;
216 can_skb_prv(skb)->skbcnt = 0;
217
218 skb_put_data(skb, &cf, sizeof(struct can_frame));
219
220 sl->dev->stats.rx_packets++;
221 sl->dev->stats.rx_bytes += cf.can_dlc;
222 netif_rx_ni(skb);
223 }
224
225
226 static void slcan_unesc(struct slcan *sl, unsigned char s)
227 {
228 if ((s == '\r') || (s == '\a')) {
229 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
230 (sl->rcount > 4)) {
231 slc_bump(sl);
232 }
233 sl->rcount = 0;
234 } else {
235 if (!test_bit(SLF_ERROR, &sl->flags)) {
236 if (sl->rcount < SLC_MTU) {
237 sl->rbuff[sl->rcount++] = s;
238 return;
239 } else {
240 sl->dev->stats.rx_over_errors++;
241 set_bit(SLF_ERROR, &sl->flags);
242 }
243 }
244 }
245 }
246
247
248
249
250
251
252 static void slc_encaps(struct slcan *sl, struct can_frame *cf)
253 {
254 int actual, i;
255 unsigned char *pos;
256 unsigned char *endpos;
257 canid_t id = cf->can_id;
258
259 pos = sl->xbuff;
260
261 if (cf->can_id & CAN_RTR_FLAG)
262 *pos = 'R';
263 else
264 *pos = 'T';
265
266
267 if (cf->can_id & CAN_EFF_FLAG) {
268 id &= CAN_EFF_MASK;
269 endpos = pos + SLC_EFF_ID_LEN;
270 } else {
271 *pos |= 0x20;
272 id &= CAN_SFF_MASK;
273 endpos = pos + SLC_SFF_ID_LEN;
274 }
275
276
277 pos++;
278 while (endpos >= pos) {
279 *endpos-- = hex_asc_upper[id & 0xf];
280 id >>= 4;
281 }
282
283 pos += (cf->can_id & CAN_EFF_FLAG) ? SLC_EFF_ID_LEN : SLC_SFF_ID_LEN;
284
285 *pos++ = cf->can_dlc + '0';
286
287
288 if (!(cf->can_id & CAN_RTR_FLAG)) {
289 for (i = 0; i < cf->can_dlc; i++)
290 pos = hex_byte_pack_upper(pos, cf->data[i]);
291 }
292
293 *pos++ = '\r';
294
295
296
297
298
299
300
301
302
303 set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
304 actual = sl->tty->ops->write(sl->tty, sl->xbuff, pos - sl->xbuff);
305 sl->xleft = (pos - sl->xbuff) - actual;
306 sl->xhead = sl->xbuff + actual;
307 sl->dev->stats.tx_bytes += cf->can_dlc;
308 }
309
310
311 static void slcan_transmit(struct work_struct *work)
312 {
313 struct slcan *sl = container_of(work, struct slcan, tx_work);
314 int actual;
315
316 spin_lock_bh(&sl->lock);
317
318 if (!sl->tty || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev)) {
319 spin_unlock_bh(&sl->lock);
320 return;
321 }
322
323 if (sl->xleft <= 0) {
324
325
326 sl->dev->stats.tx_packets++;
327 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
328 spin_unlock_bh(&sl->lock);
329 netif_wake_queue(sl->dev);
330 return;
331 }
332
333 actual = sl->tty->ops->write(sl->tty, sl->xhead, sl->xleft);
334 sl->xleft -= actual;
335 sl->xhead += actual;
336 spin_unlock_bh(&sl->lock);
337 }
338
339
340
341
342
343 static void slcan_write_wakeup(struct tty_struct *tty)
344 {
345 struct slcan *sl;
346
347 rcu_read_lock();
348 sl = rcu_dereference(tty->disc_data);
349 if (!sl)
350 goto out;
351
352 schedule_work(&sl->tx_work);
353 out:
354 rcu_read_unlock();
355 }
356
357
358 static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
359 {
360 struct slcan *sl = netdev_priv(dev);
361
362 if (skb->len != CAN_MTU)
363 goto out;
364
365 spin_lock(&sl->lock);
366 if (!netif_running(dev)) {
367 spin_unlock(&sl->lock);
368 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
369 goto out;
370 }
371 if (sl->tty == NULL) {
372 spin_unlock(&sl->lock);
373 goto out;
374 }
375
376 netif_stop_queue(sl->dev);
377 slc_encaps(sl, (struct can_frame *) skb->data);
378 spin_unlock(&sl->lock);
379
380 out:
381 kfree_skb(skb);
382 return NETDEV_TX_OK;
383 }
384
385
386
387
388
389
390
391 static int slc_close(struct net_device *dev)
392 {
393 struct slcan *sl = netdev_priv(dev);
394
395 spin_lock_bh(&sl->lock);
396 if (sl->tty) {
397
398 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
399 }
400 netif_stop_queue(dev);
401 sl->rcount = 0;
402 sl->xleft = 0;
403 spin_unlock_bh(&sl->lock);
404
405 return 0;
406 }
407
408
409 static int slc_open(struct net_device *dev)
410 {
411 struct slcan *sl = netdev_priv(dev);
412
413 if (sl->tty == NULL)
414 return -ENODEV;
415
416 sl->flags &= (1 << SLF_INUSE);
417 netif_start_queue(dev);
418 return 0;
419 }
420
421
422 static void slc_free_netdev(struct net_device *dev)
423 {
424 int i = dev->base_addr;
425
426 slcan_devs[i] = NULL;
427 }
428
429 static int slcan_change_mtu(struct net_device *dev, int new_mtu)
430 {
431 return -EINVAL;
432 }
433
434 static const struct net_device_ops slc_netdev_ops = {
435 .ndo_open = slc_open,
436 .ndo_stop = slc_close,
437 .ndo_start_xmit = slc_xmit,
438 .ndo_change_mtu = slcan_change_mtu,
439 };
440
441 static void slc_setup(struct net_device *dev)
442 {
443 dev->netdev_ops = &slc_netdev_ops;
444 dev->needs_free_netdev = true;
445 dev->priv_destructor = slc_free_netdev;
446
447 dev->hard_header_len = 0;
448 dev->addr_len = 0;
449 dev->tx_queue_len = 10;
450
451 dev->mtu = CAN_MTU;
452 dev->type = ARPHRD_CAN;
453
454
455 dev->flags = IFF_NOARP;
456 dev->features = NETIF_F_HW_CSUM;
457 }
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472 static void slcan_receive_buf(struct tty_struct *tty,
473 const unsigned char *cp, char *fp, int count)
474 {
475 struct slcan *sl = (struct slcan *) tty->disc_data;
476
477 if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
478 return;
479
480
481 while (count--) {
482 if (fp && *fp++) {
483 if (!test_and_set_bit(SLF_ERROR, &sl->flags))
484 sl->dev->stats.rx_errors++;
485 cp++;
486 continue;
487 }
488 slcan_unesc(sl, *cp++);
489 }
490 }
491
492
493
494
495
496
497 static void slc_sync(void)
498 {
499 int i;
500 struct net_device *dev;
501 struct slcan *sl;
502
503 for (i = 0; i < maxdev; i++) {
504 dev = slcan_devs[i];
505 if (dev == NULL)
506 break;
507
508 sl = netdev_priv(dev);
509 if (sl->tty)
510 continue;
511 if (dev->flags & IFF_UP)
512 dev_close(dev);
513 }
514 }
515
516
517 static struct slcan *slc_alloc(void)
518 {
519 int i;
520 char name[IFNAMSIZ];
521 struct net_device *dev = NULL;
522 struct slcan *sl;
523 int size;
524
525 for (i = 0; i < maxdev; i++) {
526 dev = slcan_devs[i];
527 if (dev == NULL)
528 break;
529
530 }
531
532
533 if (i >= maxdev)
534 return NULL;
535
536 sprintf(name, "slcan%d", i);
537 size = ALIGN(sizeof(*sl), NETDEV_ALIGN) + sizeof(struct can_ml_priv);
538 dev = alloc_netdev(size, name, NET_NAME_UNKNOWN, slc_setup);
539 if (!dev)
540 return NULL;
541
542 dev->base_addr = i;
543 sl = netdev_priv(dev);
544 dev->ml_priv = (void *)sl + ALIGN(sizeof(*sl), NETDEV_ALIGN);
545
546
547 sl->magic = SLCAN_MAGIC;
548 sl->dev = dev;
549 spin_lock_init(&sl->lock);
550 INIT_WORK(&sl->tx_work, slcan_transmit);
551 slcan_devs[i] = dev;
552
553 return sl;
554 }
555
556
557
558
559
560
561
562
563
564
565
566 static int slcan_open(struct tty_struct *tty)
567 {
568 struct slcan *sl;
569 int err;
570
571 if (!capable(CAP_NET_ADMIN))
572 return -EPERM;
573
574 if (tty->ops->write == NULL)
575 return -EOPNOTSUPP;
576
577
578
579
580
581 rtnl_lock();
582
583
584 slc_sync();
585
586 sl = tty->disc_data;
587
588 err = -EEXIST;
589
590 if (sl && sl->magic == SLCAN_MAGIC)
591 goto err_exit;
592
593
594 err = -ENFILE;
595 sl = slc_alloc();
596 if (sl == NULL)
597 goto err_exit;
598
599 sl->tty = tty;
600 tty->disc_data = sl;
601
602 if (!test_bit(SLF_INUSE, &sl->flags)) {
603
604 sl->rcount = 0;
605 sl->xleft = 0;
606
607 set_bit(SLF_INUSE, &sl->flags);
608
609 err = register_netdevice(sl->dev);
610 if (err)
611 goto err_free_chan;
612 }
613
614
615 rtnl_unlock();
616 tty->receive_room = 65536;
617
618
619 return 0;
620
621 err_free_chan:
622 sl->tty = NULL;
623 tty->disc_data = NULL;
624 clear_bit(SLF_INUSE, &sl->flags);
625 slc_free_netdev(sl->dev);
626
627 rtnl_unlock();
628 free_netdev(sl->dev);
629 return err;
630
631 err_exit:
632 rtnl_unlock();
633
634
635 return err;
636 }
637
638
639
640
641
642
643
644
645
646 static void slcan_close(struct tty_struct *tty)
647 {
648 struct slcan *sl = (struct slcan *) tty->disc_data;
649
650
651 if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty)
652 return;
653
654 spin_lock_bh(&sl->lock);
655 rcu_assign_pointer(tty->disc_data, NULL);
656 sl->tty = NULL;
657 spin_unlock_bh(&sl->lock);
658
659 synchronize_rcu();
660 flush_work(&sl->tx_work);
661
662
663 unregister_netdev(sl->dev);
664
665 }
666
667 static int slcan_hangup(struct tty_struct *tty)
668 {
669 slcan_close(tty);
670 return 0;
671 }
672
673
674 static int slcan_ioctl(struct tty_struct *tty, struct file *file,
675 unsigned int cmd, unsigned long arg)
676 {
677 struct slcan *sl = (struct slcan *) tty->disc_data;
678 unsigned int tmp;
679
680
681 if (!sl || sl->magic != SLCAN_MAGIC)
682 return -EINVAL;
683
684 switch (cmd) {
685 case SIOCGIFNAME:
686 tmp = strlen(sl->dev->name) + 1;
687 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
688 return -EFAULT;
689 return 0;
690
691 case SIOCSIFHWADDR:
692 return -EINVAL;
693
694 default:
695 return tty_mode_ioctl(tty, file, cmd, arg);
696 }
697 }
698
699 static struct tty_ldisc_ops slc_ldisc = {
700 .owner = THIS_MODULE,
701 .magic = TTY_LDISC_MAGIC,
702 .name = "slcan",
703 .open = slcan_open,
704 .close = slcan_close,
705 .hangup = slcan_hangup,
706 .ioctl = slcan_ioctl,
707 .receive_buf = slcan_receive_buf,
708 .write_wakeup = slcan_write_wakeup,
709 };
710
711 static int __init slcan_init(void)
712 {
713 int status;
714
715 if (maxdev < 4)
716 maxdev = 4;
717
718 pr_info("slcan: serial line CAN interface driver\n");
719 pr_info("slcan: %d dynamic interface channels.\n", maxdev);
720
721 slcan_devs = kcalloc(maxdev, sizeof(struct net_device *), GFP_KERNEL);
722 if (!slcan_devs)
723 return -ENOMEM;
724
725
726 status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
727 if (status) {
728 printk(KERN_ERR "slcan: can't register line discipline\n");
729 kfree(slcan_devs);
730 }
731 return status;
732 }
733
734 static void __exit slcan_exit(void)
735 {
736 int i;
737 struct net_device *dev;
738 struct slcan *sl;
739 unsigned long timeout = jiffies + HZ;
740 int busy = 0;
741
742 if (slcan_devs == NULL)
743 return;
744
745
746
747 do {
748 if (busy)
749 msleep_interruptible(100);
750
751 busy = 0;
752 for (i = 0; i < maxdev; i++) {
753 dev = slcan_devs[i];
754 if (!dev)
755 continue;
756 sl = netdev_priv(dev);
757 spin_lock_bh(&sl->lock);
758 if (sl->tty) {
759 busy++;
760 tty_hangup(sl->tty);
761 }
762 spin_unlock_bh(&sl->lock);
763 }
764 } while (busy && time_before(jiffies, timeout));
765
766
767
768
769 for (i = 0; i < maxdev; i++) {
770 dev = slcan_devs[i];
771 if (!dev)
772 continue;
773 slcan_devs[i] = NULL;
774
775 sl = netdev_priv(dev);
776 if (sl->tty) {
777 printk(KERN_ERR "%s: tty discipline still running\n",
778 dev->name);
779 }
780
781 unregister_netdev(dev);
782 }
783
784 kfree(slcan_devs);
785 slcan_devs = NULL;
786
787 i = tty_unregister_ldisc(N_SLCAN);
788 if (i)
789 printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
790 }
791
792 module_init(slcan_init);
793 module_exit(slcan_exit);