1
2
3
4
5
6
7
8
9
10
11#include <linux/init.h>
12#include <linux/signal.h>
13#include <linux/slab.h>
14#include <linux/module.h>
15#include <linux/netdevice.h>
16#include <linux/usb.h>
17#include <linux/ethtool.h>
18
19#include <linux/can.h>
20#include <linux/can/dev.h>
21#include <linux/can/error.h>
22
23#include "pcan_usb_core.h"
24
25MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
26MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");
27MODULE_LICENSE("GPL v2");
28
29
30static const struct usb_device_id peak_usb_table[] = {
31 {
32 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USB_PRODUCT_ID),
33 .driver_info = (kernel_ulong_t)&pcan_usb,
34 }, {
35 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPRO_PRODUCT_ID),
36 .driver_info = (kernel_ulong_t)&pcan_usb_pro,
37 }, {
38 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBFD_PRODUCT_ID),
39 .driver_info = (kernel_ulong_t)&pcan_usb_fd,
40 }, {
41 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPROFD_PRODUCT_ID),
42 .driver_info = (kernel_ulong_t)&pcan_usb_pro_fd,
43 }, {
44 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBCHIP_PRODUCT_ID),
45 .driver_info = (kernel_ulong_t)&pcan_usb_chip,
46 }, {
47 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBX6_PRODUCT_ID),
48 .driver_info = (kernel_ulong_t)&pcan_usb_x6,
49 }, {
50
51 }
52};
53
54MODULE_DEVICE_TABLE(usb, peak_usb_table);
55
56
57
58
59#define DUMP_WIDTH 16
60void pcan_dump_mem(char *prompt, void *p, int l)
61{
62 pr_info("%s dumping %s (%d bytes):\n",
63 PCAN_USB_DRIVER_NAME, prompt ? prompt : "memory", l);
64 print_hex_dump(KERN_INFO, PCAN_USB_DRIVER_NAME " ", DUMP_PREFIX_NONE,
65 DUMP_WIDTH, 1, p, l, false);
66}
67
68
69
70
71void peak_usb_init_time_ref(struct peak_time_ref *time_ref,
72 const struct peak_usb_adapter *adapter)
73{
74 if (time_ref) {
75 memset(time_ref, 0, sizeof(struct peak_time_ref));
76 time_ref->adapter = adapter;
77 }
78}
79
80
81
82
83void peak_usb_update_ts_now(struct peak_time_ref *time_ref, u32 ts_now)
84{
85 time_ref->ts_dev_2 = ts_now;
86
87
88 if (ktime_to_ns(time_ref->tv_host) > 0) {
89 u32 delta_ts = time_ref->ts_dev_2 - time_ref->ts_dev_1;
90
91 if (time_ref->ts_dev_2 < time_ref->ts_dev_1)
92 delta_ts &= (1 << time_ref->adapter->ts_used_bits) - 1;
93
94 time_ref->ts_total += delta_ts;
95 }
96}
97
98
99
100
101void peak_usb_set_ts_now(struct peak_time_ref *time_ref, u32 ts_now)
102{
103 if (ktime_to_ns(time_ref->tv_host_0) == 0) {
104
105 time_ref->tv_host_0 = ktime_get();
106 time_ref->tv_host = ktime_set(0, 0);
107 } else {
108
109
110
111
112
113 if (ktime_to_ns(time_ref->tv_host)) {
114 ktime_t delta = ktime_sub(time_ref->tv_host,
115 time_ref->tv_host_0);
116 if (ktime_to_ns(delta) > (4200ull * NSEC_PER_SEC)) {
117 time_ref->tv_host_0 = time_ref->tv_host;
118 time_ref->ts_total = 0;
119 }
120 }
121
122 time_ref->tv_host = ktime_get();
123 time_ref->tick_count++;
124 }
125
126 time_ref->ts_dev_1 = time_ref->ts_dev_2;
127 peak_usb_update_ts_now(time_ref, ts_now);
128}
129
130
131
132
133void peak_usb_get_ts_time(struct peak_time_ref *time_ref, u32 ts, ktime_t *time)
134{
135
136 if (ktime_to_ns(time_ref->tv_host)) {
137 u64 delta_us;
138 s64 delta_ts = 0;
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161 if (time_ref->ts_dev_1 < time_ref->ts_dev_2) {
162
163 if (ts < time_ref->ts_dev_1)
164 delta_ts = BIT_ULL(time_ref->adapter->ts_used_bits);
165
166
167
168
169
170
171
172
173
174
175 } else if (time_ref->ts_dev_1 < ts) {
176 delta_ts = -BIT_ULL(time_ref->adapter->ts_used_bits);
177 }
178
179
180 delta_ts += (signed int)(ts - time_ref->ts_dev_2);
181
182
183 delta_ts += time_ref->ts_total;
184
185
186 delta_us = delta_ts * time_ref->adapter->us_per_ts_scale;
187 delta_us >>= time_ref->adapter->us_per_ts_shift;
188
189 *time = ktime_add_us(time_ref->tv_host_0, delta_us);
190 } else {
191 *time = ktime_get();
192 }
193}
194
195
196
197
198int peak_usb_netif_rx(struct sk_buff *skb,
199 struct peak_time_ref *time_ref, u32 ts_low)
200{
201 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
202
203 peak_usb_get_ts_time(time_ref, ts_low, &hwts->hwtstamp);
204
205 return netif_rx(skb);
206}
207
208
209
210
211static void peak_usb_read_bulk_callback(struct urb *urb)
212{
213 struct peak_usb_device *dev = urb->context;
214 struct net_device *netdev;
215 int err;
216
217 netdev = dev->netdev;
218
219 if (!netif_device_present(netdev))
220 return;
221
222
223 switch (urb->status) {
224 case 0:
225
226 break;
227
228 case -EILSEQ:
229 case -ENOENT:
230 case -ECONNRESET:
231 case -ESHUTDOWN:
232 return;
233
234 default:
235 if (net_ratelimit())
236 netdev_err(netdev,
237 "Rx urb aborted (%d)\n", urb->status);
238 goto resubmit_urb;
239 }
240
241
242 if ((urb->actual_length > 0) && (dev->adapter->dev_decode_buf)) {
243
244 if (dev->state & PCAN_USB_STATE_STARTED) {
245 err = dev->adapter->dev_decode_buf(dev, urb);
246 if (err)
247 pcan_dump_mem("received usb message",
248 urb->transfer_buffer,
249 urb->transfer_buffer_length);
250 }
251 }
252
253resubmit_urb:
254 usb_fill_bulk_urb(urb, dev->udev,
255 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in),
256 urb->transfer_buffer, dev->adapter->rx_buffer_size,
257 peak_usb_read_bulk_callback, dev);
258
259 usb_anchor_urb(urb, &dev->rx_submitted);
260 err = usb_submit_urb(urb, GFP_ATOMIC);
261 if (!err)
262 return;
263
264 usb_unanchor_urb(urb);
265
266 if (err == -ENODEV)
267 netif_device_detach(netdev);
268 else
269 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n",
270 err);
271}
272
273
274
275
276static void peak_usb_write_bulk_callback(struct urb *urb)
277{
278 struct peak_tx_urb_context *context = urb->context;
279 struct peak_usb_device *dev;
280 struct net_device *netdev;
281
282 BUG_ON(!context);
283
284 dev = context->dev;
285 netdev = dev->netdev;
286
287 atomic_dec(&dev->active_tx_urbs);
288
289 if (!netif_device_present(netdev))
290 return;
291
292
293 switch (urb->status) {
294 case 0:
295
296 netdev->stats.tx_packets++;
297 netdev->stats.tx_bytes += context->data_len;
298
299
300 netif_trans_update(netdev);
301 break;
302
303 case -EPROTO:
304 case -ENOENT:
305 case -ECONNRESET:
306 case -ESHUTDOWN:
307 break;
308
309 default:
310 if (net_ratelimit())
311 netdev_err(netdev, "Tx urb aborted (%d)\n",
312 urb->status);
313 break;
314 }
315
316
317 can_get_echo_skb(netdev, context->echo_index, NULL);
318 context->echo_index = PCAN_USB_MAX_TX_URBS;
319
320
321 if (!urb->status)
322 netif_wake_queue(netdev);
323}
324
325
326
327
328static netdev_tx_t peak_usb_ndo_start_xmit(struct sk_buff *skb,
329 struct net_device *netdev)
330{
331 struct peak_usb_device *dev = netdev_priv(netdev);
332 struct peak_tx_urb_context *context = NULL;
333 struct net_device_stats *stats = &netdev->stats;
334 struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
335 struct urb *urb;
336 u8 *obuf;
337 int i, err;
338 size_t size = dev->adapter->tx_buffer_size;
339
340 if (can_dropped_invalid_skb(netdev, skb))
341 return NETDEV_TX_OK;
342
343 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++)
344 if (dev->tx_contexts[i].echo_index == PCAN_USB_MAX_TX_URBS) {
345 context = dev->tx_contexts + i;
346 break;
347 }
348
349 if (!context) {
350
351 return NETDEV_TX_BUSY;
352 }
353
354 urb = context->urb;
355 obuf = urb->transfer_buffer;
356
357 err = dev->adapter->dev_encode_msg(dev, skb, obuf, &size);
358 if (err) {
359 if (net_ratelimit())
360 netdev_err(netdev, "packet dropped\n");
361 dev_kfree_skb(skb);
362 stats->tx_dropped++;
363 return NETDEV_TX_OK;
364 }
365
366 context->echo_index = i;
367
368
369 context->data_len = cfd->len;
370
371 usb_anchor_urb(urb, &dev->tx_submitted);
372
373 can_put_echo_skb(skb, netdev, context->echo_index, 0);
374
375 atomic_inc(&dev->active_tx_urbs);
376
377 err = usb_submit_urb(urb, GFP_ATOMIC);
378 if (err) {
379 can_free_echo_skb(netdev, context->echo_index, NULL);
380
381 usb_unanchor_urb(urb);
382
383
384 context->echo_index = PCAN_USB_MAX_TX_URBS;
385
386 atomic_dec(&dev->active_tx_urbs);
387
388 switch (err) {
389 case -ENODEV:
390 netif_device_detach(netdev);
391 break;
392 default:
393 netdev_warn(netdev, "tx urb submitting failed err=%d\n",
394 err);
395 fallthrough;
396 case -ENOENT:
397
398 stats->tx_dropped++;
399 }
400 } else {
401 netif_trans_update(netdev);
402
403
404 if (atomic_read(&dev->active_tx_urbs) >= PCAN_USB_MAX_TX_URBS)
405 netif_stop_queue(netdev);
406 }
407
408 return NETDEV_TX_OK;
409}
410
411
412
413
414
415static int peak_usb_start(struct peak_usb_device *dev)
416{
417 struct net_device *netdev = dev->netdev;
418 int err, i;
419
420 for (i = 0; i < PCAN_USB_MAX_RX_URBS; i++) {
421 struct urb *urb;
422 u8 *buf;
423
424
425 urb = usb_alloc_urb(0, GFP_KERNEL);
426 if (!urb) {
427 err = -ENOMEM;
428 break;
429 }
430
431 buf = kmalloc(dev->adapter->rx_buffer_size, GFP_KERNEL);
432 if (!buf) {
433 usb_free_urb(urb);
434 err = -ENOMEM;
435 break;
436 }
437
438 usb_fill_bulk_urb(urb, dev->udev,
439 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in),
440 buf, dev->adapter->rx_buffer_size,
441 peak_usb_read_bulk_callback, dev);
442
443
444 urb->transfer_flags |= URB_FREE_BUFFER;
445 usb_anchor_urb(urb, &dev->rx_submitted);
446
447 err = usb_submit_urb(urb, GFP_KERNEL);
448 if (err) {
449 if (err == -ENODEV)
450 netif_device_detach(dev->netdev);
451
452 usb_unanchor_urb(urb);
453 kfree(buf);
454 usb_free_urb(urb);
455 break;
456 }
457
458
459 usb_free_urb(urb);
460 }
461
462
463 if (i < PCAN_USB_MAX_RX_URBS) {
464 if (i == 0) {
465 netdev_err(netdev, "couldn't setup any rx URB\n");
466 return err;
467 }
468
469 netdev_warn(netdev, "rx performance may be slow\n");
470 }
471
472
473 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
474 struct peak_tx_urb_context *context;
475 struct urb *urb;
476 u8 *buf;
477
478
479 urb = usb_alloc_urb(0, GFP_KERNEL);
480 if (!urb) {
481 err = -ENOMEM;
482 break;
483 }
484
485 buf = kmalloc(dev->adapter->tx_buffer_size, GFP_KERNEL);
486 if (!buf) {
487 usb_free_urb(urb);
488 err = -ENOMEM;
489 break;
490 }
491
492 context = dev->tx_contexts + i;
493 context->dev = dev;
494 context->urb = urb;
495
496 usb_fill_bulk_urb(urb, dev->udev,
497 usb_sndbulkpipe(dev->udev, dev->ep_msg_out),
498 buf, dev->adapter->tx_buffer_size,
499 peak_usb_write_bulk_callback, context);
500
501
502 urb->transfer_flags |= URB_FREE_BUFFER;
503 }
504
505
506 if (i < PCAN_USB_MAX_TX_URBS) {
507 if (i == 0) {
508 netdev_err(netdev, "couldn't setup any tx URB\n");
509 goto err_tx;
510 }
511
512 netdev_warn(netdev, "tx performance may be slow\n");
513 }
514
515 if (dev->adapter->dev_start) {
516 err = dev->adapter->dev_start(dev);
517 if (err)
518 goto err_adapter;
519 }
520
521 dev->state |= PCAN_USB_STATE_STARTED;
522
523
524 if (dev->adapter->dev_set_bus) {
525 err = dev->adapter->dev_set_bus(dev, 1);
526 if (err)
527 goto err_adapter;
528 }
529
530 dev->can.state = CAN_STATE_ERROR_ACTIVE;
531
532 return 0;
533
534err_adapter:
535 if (err == -ENODEV)
536 netif_device_detach(dev->netdev);
537
538 netdev_warn(netdev, "couldn't submit control: %d\n", err);
539
540 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
541 usb_free_urb(dev->tx_contexts[i].urb);
542 dev->tx_contexts[i].urb = NULL;
543 }
544err_tx:
545 usb_kill_anchored_urbs(&dev->rx_submitted);
546
547 return err;
548}
549
550
551
552
553static int peak_usb_ndo_open(struct net_device *netdev)
554{
555 struct peak_usb_device *dev = netdev_priv(netdev);
556 int err;
557
558
559 err = open_candev(netdev);
560 if (err)
561 return err;
562
563
564 err = peak_usb_start(dev);
565 if (err) {
566 netdev_err(netdev, "couldn't start device: %d\n", err);
567 close_candev(netdev);
568 return err;
569 }
570
571 netif_start_queue(netdev);
572
573 return 0;
574}
575
576
577
578
579static void peak_usb_unlink_all_urbs(struct peak_usb_device *dev)
580{
581 int i;
582
583
584 usb_kill_anchored_urbs(&dev->rx_submitted);
585
586
587 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) {
588 struct urb *urb = dev->tx_contexts[i].urb;
589
590 if (!urb ||
591 dev->tx_contexts[i].echo_index != PCAN_USB_MAX_TX_URBS) {
592
593
594
595
596 continue;
597 }
598
599 usb_free_urb(urb);
600 dev->tx_contexts[i].urb = NULL;
601 }
602
603
604 usb_kill_anchored_urbs(&dev->tx_submitted);
605 atomic_set(&dev->active_tx_urbs, 0);
606}
607
608
609
610
611static int peak_usb_ndo_stop(struct net_device *netdev)
612{
613 struct peak_usb_device *dev = netdev_priv(netdev);
614
615 dev->state &= ~PCAN_USB_STATE_STARTED;
616 netif_stop_queue(netdev);
617
618 close_candev(netdev);
619
620 dev->can.state = CAN_STATE_STOPPED;
621
622
623 peak_usb_unlink_all_urbs(dev);
624
625 if (dev->adapter->dev_stop)
626 dev->adapter->dev_stop(dev);
627
628
629 if (dev->adapter->dev_set_bus) {
630 int err = dev->adapter->dev_set_bus(dev, 0);
631
632 if (err)
633 return err;
634 }
635
636 return 0;
637}
638
639
640
641
642void peak_usb_restart_complete(struct peak_usb_device *dev)
643{
644
645 dev->can.state = CAN_STATE_ERROR_ACTIVE;
646
647
648 netif_wake_queue(dev->netdev);
649}
650
651void peak_usb_async_complete(struct urb *urb)
652{
653 kfree(urb->transfer_buffer);
654 usb_free_urb(urb);
655}
656
657
658
659
660
661static int peak_usb_restart(struct peak_usb_device *dev)
662{
663 struct urb *urb;
664 int err;
665 u8 *buf;
666
667
668
669
670
671 if (!dev->adapter->dev_restart_async) {
672 peak_usb_restart_complete(dev);
673 return 0;
674 }
675
676
677 urb = usb_alloc_urb(0, GFP_ATOMIC);
678 if (!urb)
679 return -ENOMEM;
680
681
682 buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_ATOMIC);
683 if (!buf) {
684 usb_free_urb(urb);
685 return -ENOMEM;
686 }
687
688
689 err = dev->adapter->dev_restart_async(dev, urb, buf);
690 if (!err)
691 return 0;
692
693 kfree(buf);
694 usb_free_urb(urb);
695
696 return err;
697}
698
699
700
701
702
703static int peak_usb_set_mode(struct net_device *netdev, enum can_mode mode)
704{
705 struct peak_usb_device *dev = netdev_priv(netdev);
706 int err = 0;
707
708 switch (mode) {
709 case CAN_MODE_START:
710 err = peak_usb_restart(dev);
711 if (err)
712 netdev_err(netdev, "couldn't start device (err %d)\n",
713 err);
714 break;
715
716 default:
717 return -EOPNOTSUPP;
718 }
719
720 return err;
721}
722
723
724
725
726static int peak_usb_set_bittiming(struct net_device *netdev)
727{
728 struct peak_usb_device *dev = netdev_priv(netdev);
729 const struct peak_usb_adapter *pa = dev->adapter;
730
731 if (pa->dev_set_bittiming) {
732 struct can_bittiming *bt = &dev->can.bittiming;
733 int err = pa->dev_set_bittiming(dev, bt);
734
735 if (err)
736 netdev_info(netdev, "couldn't set bitrate (err %d)\n",
737 err);
738 return err;
739 }
740
741 return 0;
742}
743
744
745
746
747static int peak_usb_set_data_bittiming(struct net_device *netdev)
748{
749 struct peak_usb_device *dev = netdev_priv(netdev);
750 const struct peak_usb_adapter *pa = dev->adapter;
751
752 if (pa->dev_set_data_bittiming) {
753 struct can_bittiming *bt = &dev->can.data_bittiming;
754 int err = pa->dev_set_data_bittiming(dev, bt);
755
756 if (err)
757 netdev_info(netdev,
758 "couldn't set data bitrate (err %d)\n",
759 err);
760
761 return err;
762 }
763
764 return 0;
765}
766
767static const struct net_device_ops peak_usb_netdev_ops = {
768 .ndo_open = peak_usb_ndo_open,
769 .ndo_stop = peak_usb_ndo_stop,
770 .ndo_start_xmit = peak_usb_ndo_start_xmit,
771 .ndo_change_mtu = can_change_mtu,
772};
773
774
775
776
777
778static int peak_usb_create_dev(const struct peak_usb_adapter *peak_usb_adapter,
779 struct usb_interface *intf, int ctrl_idx)
780{
781 struct usb_device *usb_dev = interface_to_usbdev(intf);
782 int sizeof_candev = peak_usb_adapter->sizeof_dev_private;
783 struct peak_usb_device *dev;
784 struct net_device *netdev;
785 int i, err;
786 u16 tmp16;
787
788 if (sizeof_candev < sizeof(struct peak_usb_device))
789 sizeof_candev = sizeof(struct peak_usb_device);
790
791 netdev = alloc_candev(sizeof_candev, PCAN_USB_MAX_TX_URBS);
792 if (!netdev) {
793 dev_err(&intf->dev, "%s: couldn't alloc candev\n",
794 PCAN_USB_DRIVER_NAME);
795 return -ENOMEM;
796 }
797
798 dev = netdev_priv(netdev);
799
800
801 dev->cmd_buf = kzalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL);
802 if (!dev->cmd_buf) {
803 err = -ENOMEM;
804 goto lbl_free_candev;
805 }
806
807 dev->udev = usb_dev;
808 dev->netdev = netdev;
809 dev->adapter = peak_usb_adapter;
810 dev->ctrl_idx = ctrl_idx;
811 dev->state = PCAN_USB_STATE_CONNECTED;
812
813 dev->ep_msg_in = peak_usb_adapter->ep_msg_in;
814 dev->ep_msg_out = peak_usb_adapter->ep_msg_out[ctrl_idx];
815
816 dev->can.clock = peak_usb_adapter->clock;
817 dev->can.bittiming_const = peak_usb_adapter->bittiming_const;
818 dev->can.do_set_bittiming = peak_usb_set_bittiming;
819 dev->can.data_bittiming_const = peak_usb_adapter->data_bittiming_const;
820 dev->can.do_set_data_bittiming = peak_usb_set_data_bittiming;
821 dev->can.do_set_mode = peak_usb_set_mode;
822 dev->can.do_get_berr_counter = peak_usb_adapter->do_get_berr_counter;
823 dev->can.ctrlmode_supported = peak_usb_adapter->ctrlmode_supported;
824
825 netdev->netdev_ops = &peak_usb_netdev_ops;
826
827 netdev->flags |= IFF_ECHO;
828
829
830 netdev->ethtool_ops = peak_usb_adapter->ethtool_ops;
831
832 init_usb_anchor(&dev->rx_submitted);
833
834 init_usb_anchor(&dev->tx_submitted);
835 atomic_set(&dev->active_tx_urbs, 0);
836
837 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++)
838 dev->tx_contexts[i].echo_index = PCAN_USB_MAX_TX_URBS;
839
840 dev->prev_siblings = usb_get_intfdata(intf);
841 usb_set_intfdata(intf, dev);
842
843 SET_NETDEV_DEV(netdev, &intf->dev);
844 netdev->dev_id = ctrl_idx;
845
846 err = register_candev(netdev);
847 if (err) {
848 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
849 goto lbl_restore_intf_data;
850 }
851
852 if (dev->prev_siblings)
853 (dev->prev_siblings)->next_siblings = dev;
854
855
856 tmp16 = le16_to_cpu(usb_dev->descriptor.bcdDevice);
857 dev->device_rev = tmp16 >> 8;
858
859 if (dev->adapter->dev_init) {
860 err = dev->adapter->dev_init(dev);
861 if (err)
862 goto lbl_unregister_candev;
863 }
864
865
866 if (dev->adapter->dev_set_bus) {
867 err = dev->adapter->dev_set_bus(dev, 0);
868 if (err)
869 goto adap_dev_free;
870 }
871
872
873 if (dev->adapter->dev_get_device_id)
874 dev->adapter->dev_get_device_id(dev, &dev->device_number);
875
876 netdev_info(netdev, "attached to %s channel %u (device %u)\n",
877 peak_usb_adapter->name, ctrl_idx, dev->device_number);
878
879 return 0;
880
881adap_dev_free:
882 if (dev->adapter->dev_free)
883 dev->adapter->dev_free(dev);
884
885lbl_unregister_candev:
886 unregister_candev(netdev);
887
888lbl_restore_intf_data:
889 usb_set_intfdata(intf, dev->prev_siblings);
890 kfree(dev->cmd_buf);
891
892lbl_free_candev:
893 free_candev(netdev);
894
895 return err;
896}
897
898
899
900
901static void peak_usb_disconnect(struct usb_interface *intf)
902{
903 struct peak_usb_device *dev;
904 struct peak_usb_device *dev_prev_siblings;
905
906
907 for (dev = usb_get_intfdata(intf); dev; dev = dev_prev_siblings) {
908 struct net_device *netdev = dev->netdev;
909 char name[IFNAMSIZ];
910
911 dev_prev_siblings = dev->prev_siblings;
912 dev->state &= ~PCAN_USB_STATE_CONNECTED;
913 strlcpy(name, netdev->name, IFNAMSIZ);
914
915 unregister_netdev(netdev);
916
917 kfree(dev->cmd_buf);
918 dev->next_siblings = NULL;
919 if (dev->adapter->dev_free)
920 dev->adapter->dev_free(dev);
921
922 free_candev(netdev);
923 dev_info(&intf->dev, "%s removed\n", name);
924 }
925
926 usb_set_intfdata(intf, NULL);
927}
928
929
930
931
932static int peak_usb_probe(struct usb_interface *intf,
933 const struct usb_device_id *id)
934{
935 const struct peak_usb_adapter *peak_usb_adapter;
936 int i, err = -ENOMEM;
937
938
939 peak_usb_adapter = (const struct peak_usb_adapter *)id->driver_info;
940
941
942 if (peak_usb_adapter->intf_probe) {
943 err = peak_usb_adapter->intf_probe(intf);
944 if (err)
945 return err;
946 }
947
948 for (i = 0; i < peak_usb_adapter->ctrl_count; i++) {
949 err = peak_usb_create_dev(peak_usb_adapter, intf, i);
950 if (err) {
951
952 peak_usb_disconnect(intf);
953 break;
954 }
955 }
956
957 return err;
958}
959
960
961static struct usb_driver peak_usb_driver = {
962 .name = PCAN_USB_DRIVER_NAME,
963 .disconnect = peak_usb_disconnect,
964 .probe = peak_usb_probe,
965 .id_table = peak_usb_table,
966};
967
968static int __init peak_usb_init(void)
969{
970 int err;
971
972
973 err = usb_register(&peak_usb_driver);
974 if (err)
975 pr_err("%s: usb_register failed (err %d)\n",
976 PCAN_USB_DRIVER_NAME, err);
977
978 return err;
979}
980
981static int peak_usb_do_device_exit(struct device *d, void *arg)
982{
983 struct usb_interface *intf = to_usb_interface(d);
984 struct peak_usb_device *dev;
985
986
987 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) {
988 struct net_device *netdev = dev->netdev;
989
990 if (netif_device_present(netdev))
991 if (dev->adapter->dev_exit)
992 dev->adapter->dev_exit(dev);
993 }
994
995 return 0;
996}
997
998static void __exit peak_usb_exit(void)
999{
1000 int err;
1001
1002
1003 err = driver_for_each_device(&peak_usb_driver.drvwrap.driver, NULL,
1004 NULL, peak_usb_do_device_exit);
1005 if (err)
1006 pr_err("%s: failed to stop all can devices (err %d)\n",
1007 PCAN_USB_DRIVER_NAME, err);
1008
1009
1010 usb_deregister(&peak_usb_driver);
1011
1012 pr_info("%s: PCAN-USB interfaces driver unloaded\n",
1013 PCAN_USB_DRIVER_NAME);
1014}
1015
1016module_init(peak_usb_init);
1017module_exit(peak_usb_exit);
1018