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
60MODULE_ALIAS_LDISC(N_SLCAN);
61MODULE_DESCRIPTION("serial line CAN interface");
62MODULE_LICENSE("GPL");
63MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
64
65#define SLCAN_MAGIC 0x53CA
66
67static int maxdev = 10;
68
69
70module_param(maxdev, int, 0);
71MODULE_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
80struct 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
101static 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
143static 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 fallthrough;
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 fallthrough;
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
226static 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
252static 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
311static 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
343static 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 schedule_work(&sl->tx_work);
351 rcu_read_unlock();
352}
353
354
355static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
356{
357 struct slcan *sl = netdev_priv(dev);
358
359 if (skb->len != CAN_MTU)
360 goto out;
361
362 spin_lock(&sl->lock);
363 if (!netif_running(dev)) {
364 spin_unlock(&sl->lock);
365 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
366 goto out;
367 }
368 if (sl->tty == NULL) {
369 spin_unlock(&sl->lock);
370 goto out;
371 }
372
373 netif_stop_queue(sl->dev);
374 slc_encaps(sl, (struct can_frame *) skb->data);
375 spin_unlock(&sl->lock);
376
377out:
378 kfree_skb(skb);
379 return NETDEV_TX_OK;
380}
381
382
383
384
385
386
387
388static int slc_close(struct net_device *dev)
389{
390 struct slcan *sl = netdev_priv(dev);
391
392 spin_lock_bh(&sl->lock);
393 if (sl->tty) {
394
395 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
396 }
397 netif_stop_queue(dev);
398 sl->rcount = 0;
399 sl->xleft = 0;
400 spin_unlock_bh(&sl->lock);
401
402 return 0;
403}
404
405
406static int slc_open(struct net_device *dev)
407{
408 struct slcan *sl = netdev_priv(dev);
409
410 if (sl->tty == NULL)
411 return -ENODEV;
412
413 sl->flags &= (1 << SLF_INUSE);
414 netif_start_queue(dev);
415 return 0;
416}
417
418
419static void slc_free_netdev(struct net_device *dev)
420{
421 int i = dev->base_addr;
422
423 slcan_devs[i] = NULL;
424}
425
426static int slcan_change_mtu(struct net_device *dev, int new_mtu)
427{
428 return -EINVAL;
429}
430
431static const struct net_device_ops slc_netdev_ops = {
432 .ndo_open = slc_open,
433 .ndo_stop = slc_close,
434 .ndo_start_xmit = slc_xmit,
435 .ndo_change_mtu = slcan_change_mtu,
436};
437
438static void slc_setup(struct net_device *dev)
439{
440 dev->netdev_ops = &slc_netdev_ops;
441 dev->needs_free_netdev = true;
442 dev->priv_destructor = slc_free_netdev;
443
444 dev->hard_header_len = 0;
445 dev->addr_len = 0;
446 dev->tx_queue_len = 10;
447
448 dev->mtu = CAN_MTU;
449 dev->type = ARPHRD_CAN;
450
451
452 dev->flags = IFF_NOARP;
453 dev->features = NETIF_F_HW_CSUM;
454}
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469static void slcan_receive_buf(struct tty_struct *tty,
470 const unsigned char *cp, char *fp, int count)
471{
472 struct slcan *sl = (struct slcan *) tty->disc_data;
473
474 if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
475 return;
476
477
478 while (count--) {
479 if (fp && *fp++) {
480 if (!test_and_set_bit(SLF_ERROR, &sl->flags))
481 sl->dev->stats.rx_errors++;
482 cp++;
483 continue;
484 }
485 slcan_unesc(sl, *cp++);
486 }
487}
488
489
490
491
492
493
494static void slc_sync(void)
495{
496 int i;
497 struct net_device *dev;
498 struct slcan *sl;
499
500 for (i = 0; i < maxdev; i++) {
501 dev = slcan_devs[i];
502 if (dev == NULL)
503 break;
504
505 sl = netdev_priv(dev);
506 if (sl->tty)
507 continue;
508 if (dev->flags & IFF_UP)
509 dev_close(dev);
510 }
511}
512
513
514static struct slcan *slc_alloc(void)
515{
516 int i;
517 char name[IFNAMSIZ];
518 struct net_device *dev = NULL;
519 struct slcan *sl;
520 int size;
521
522 for (i = 0; i < maxdev; i++) {
523 dev = slcan_devs[i];
524 if (dev == NULL)
525 break;
526
527 }
528
529
530 if (i >= maxdev)
531 return NULL;
532
533 sprintf(name, "slcan%d", i);
534 size = ALIGN(sizeof(*sl), NETDEV_ALIGN) + sizeof(struct can_ml_priv);
535 dev = alloc_netdev(size, name, NET_NAME_UNKNOWN, slc_setup);
536 if (!dev)
537 return NULL;
538
539 dev->base_addr = i;
540 sl = netdev_priv(dev);
541 dev->ml_priv = (void *)sl + ALIGN(sizeof(*sl), NETDEV_ALIGN);
542
543
544 sl->magic = SLCAN_MAGIC;
545 sl->dev = dev;
546 spin_lock_init(&sl->lock);
547 INIT_WORK(&sl->tx_work, slcan_transmit);
548 slcan_devs[i] = dev;
549
550 return sl;
551}
552
553
554
555
556
557
558
559
560
561
562
563static int slcan_open(struct tty_struct *tty)
564{
565 struct slcan *sl;
566 int err;
567
568 if (!capable(CAP_NET_ADMIN))
569 return -EPERM;
570
571 if (tty->ops->write == NULL)
572 return -EOPNOTSUPP;
573
574
575
576
577
578 rtnl_lock();
579
580
581 slc_sync();
582
583 sl = tty->disc_data;
584
585 err = -EEXIST;
586
587 if (sl && sl->magic == SLCAN_MAGIC)
588 goto err_exit;
589
590
591 err = -ENFILE;
592 sl = slc_alloc();
593 if (sl == NULL)
594 goto err_exit;
595
596 sl->tty = tty;
597 tty->disc_data = sl;
598
599 if (!test_bit(SLF_INUSE, &sl->flags)) {
600
601 sl->rcount = 0;
602 sl->xleft = 0;
603
604 set_bit(SLF_INUSE, &sl->flags);
605
606 err = register_netdevice(sl->dev);
607 if (err)
608 goto err_free_chan;
609 }
610
611
612 rtnl_unlock();
613 tty->receive_room = 65536;
614
615
616 return 0;
617
618err_free_chan:
619 sl->tty = NULL;
620 tty->disc_data = NULL;
621 clear_bit(SLF_INUSE, &sl->flags);
622 slc_free_netdev(sl->dev);
623
624 rtnl_unlock();
625 free_netdev(sl->dev);
626 return err;
627
628err_exit:
629 rtnl_unlock();
630
631
632 return err;
633}
634
635
636
637
638
639
640
641
642
643static void slcan_close(struct tty_struct *tty)
644{
645 struct slcan *sl = (struct slcan *) tty->disc_data;
646
647
648 if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty)
649 return;
650
651 spin_lock_bh(&sl->lock);
652 rcu_assign_pointer(tty->disc_data, NULL);
653 sl->tty = NULL;
654 spin_unlock_bh(&sl->lock);
655
656 synchronize_rcu();
657 flush_work(&sl->tx_work);
658
659
660 unregister_netdev(sl->dev);
661
662}
663
664static int slcan_hangup(struct tty_struct *tty)
665{
666 slcan_close(tty);
667 return 0;
668}
669
670
671static int slcan_ioctl(struct tty_struct *tty, struct file *file,
672 unsigned int cmd, unsigned long arg)
673{
674 struct slcan *sl = (struct slcan *) tty->disc_data;
675 unsigned int tmp;
676
677
678 if (!sl || sl->magic != SLCAN_MAGIC)
679 return -EINVAL;
680
681 switch (cmd) {
682 case SIOCGIFNAME:
683 tmp = strlen(sl->dev->name) + 1;
684 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
685 return -EFAULT;
686 return 0;
687
688 case SIOCSIFHWADDR:
689 return -EINVAL;
690
691 default:
692 return tty_mode_ioctl(tty, file, cmd, arg);
693 }
694}
695
696static struct tty_ldisc_ops slc_ldisc = {
697 .owner = THIS_MODULE,
698 .magic = TTY_LDISC_MAGIC,
699 .name = "slcan",
700 .open = slcan_open,
701 .close = slcan_close,
702 .hangup = slcan_hangup,
703 .ioctl = slcan_ioctl,
704 .receive_buf = slcan_receive_buf,
705 .write_wakeup = slcan_write_wakeup,
706};
707
708static int __init slcan_init(void)
709{
710 int status;
711
712 if (maxdev < 4)
713 maxdev = 4;
714
715 pr_info("slcan: serial line CAN interface driver\n");
716 pr_info("slcan: %d dynamic interface channels.\n", maxdev);
717
718 slcan_devs = kcalloc(maxdev, sizeof(struct net_device *), GFP_KERNEL);
719 if (!slcan_devs)
720 return -ENOMEM;
721
722
723 status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
724 if (status) {
725 printk(KERN_ERR "slcan: can't register line discipline\n");
726 kfree(slcan_devs);
727 }
728 return status;
729}
730
731static void __exit slcan_exit(void)
732{
733 int i;
734 struct net_device *dev;
735 struct slcan *sl;
736 unsigned long timeout = jiffies + HZ;
737 int busy = 0;
738
739 if (slcan_devs == NULL)
740 return;
741
742
743
744 do {
745 if (busy)
746 msleep_interruptible(100);
747
748 busy = 0;
749 for (i = 0; i < maxdev; i++) {
750 dev = slcan_devs[i];
751 if (!dev)
752 continue;
753 sl = netdev_priv(dev);
754 spin_lock_bh(&sl->lock);
755 if (sl->tty) {
756 busy++;
757 tty_hangup(sl->tty);
758 }
759 spin_unlock_bh(&sl->lock);
760 }
761 } while (busy && time_before(jiffies, timeout));
762
763
764
765
766 for (i = 0; i < maxdev; i++) {
767 dev = slcan_devs[i];
768 if (!dev)
769 continue;
770 slcan_devs[i] = NULL;
771
772 sl = netdev_priv(dev);
773 if (sl->tty) {
774 printk(KERN_ERR "%s: tty discipline still running\n",
775 dev->name);
776 }
777
778 unregister_netdev(dev);
779 }
780
781 kfree(slcan_devs);
782 slcan_devs = NULL;
783
784 i = tty_unregister_ldisc(N_SLCAN);
785 if (i)
786 printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
787}
788
789module_init(slcan_init);
790module_exit(slcan_exit);
791