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.len = 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.len = 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.len >= '0' && cf.len < '9')
186 cf.len -= '0';
187 else
188 return;
189
190
191 if (!(cf.can_id & CAN_RTR_FLAG)) {
192 for (i = 0; i < cf.len; 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.len;
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->len + '0';
286
287
288 if (!(cf->can_id & CAN_RTR_FLAG)) {
289 for (i = 0; i < cf->len; 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->len;
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, const char *fp,
471 int count)
472{
473 struct slcan *sl = (struct slcan *) tty->disc_data;
474
475 if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
476 return;
477
478
479 while (count--) {
480 if (fp && *fp++) {
481 if (!test_and_set_bit(SLF_ERROR, &sl->flags))
482 sl->dev->stats.rx_errors++;
483 cp++;
484 continue;
485 }
486 slcan_unesc(sl, *cp++);
487 }
488}
489
490
491
492
493
494
495static void slc_sync(void)
496{
497 int i;
498 struct net_device *dev;
499 struct slcan *sl;
500
501 for (i = 0; i < maxdev; i++) {
502 dev = slcan_devs[i];
503 if (dev == NULL)
504 break;
505
506 sl = netdev_priv(dev);
507 if (sl->tty)
508 continue;
509 if (dev->flags & IFF_UP)
510 dev_close(dev);
511 }
512}
513
514
515static struct slcan *slc_alloc(void)
516{
517 int i;
518 char name[IFNAMSIZ];
519 struct net_device *dev = NULL;
520 struct can_ml_priv *can_ml;
521 struct slcan *sl;
522 int size;
523
524 for (i = 0; i < maxdev; i++) {
525 dev = slcan_devs[i];
526 if (dev == NULL)
527 break;
528
529 }
530
531
532 if (i >= maxdev)
533 return NULL;
534
535 sprintf(name, "slcan%d", i);
536 size = ALIGN(sizeof(*sl), NETDEV_ALIGN) + sizeof(struct can_ml_priv);
537 dev = alloc_netdev(size, name, NET_NAME_UNKNOWN, slc_setup);
538 if (!dev)
539 return NULL;
540
541 dev->base_addr = i;
542 sl = netdev_priv(dev);
543 can_ml = (void *)sl + ALIGN(sizeof(*sl), NETDEV_ALIGN);
544 can_set_ml_priv(dev, can_ml);
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
566static 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
621err_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
631err_exit:
632 rtnl_unlock();
633
634
635 return err;
636}
637
638
639
640
641
642
643
644
645
646static 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
667static int slcan_hangup(struct tty_struct *tty)
668{
669 slcan_close(tty);
670 return 0;
671}
672
673
674static 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
699static struct tty_ldisc_ops slc_ldisc = {
700 .owner = THIS_MODULE,
701 .num = N_SLCAN,
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
711static 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(&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
734static 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 tty_unregister_ldisc(&slc_ldisc);
788}
789
790module_init(slcan_init);
791module_exit(slcan_exit);
792