2 * CAN driver for PEAK System USB adapters
3 * Derived from the PCAN project file driver/src/pcan_usb_core.c
5 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
6 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
8 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; version 2 of the License.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 #include <linux/init.h>
20 #include <linux/signal.h>
21 #include <linux/slab.h>
22 #include <linux/module.h>
23 #include <linux/netdevice.h>
24 #include <linux/usb.h>
26 #include <linux/can.h>
27 #include <linux/can/dev.h>
28 #include <linux/can/error.h>
30 #include "pcan_usb_core.h"
32 MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
33 MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");
34 MODULE_LICENSE("GPL v2");
36 /* Table of devices that work with this driver */
37 static struct usb_device_id peak_usb_table
[] = {
38 {USB_DEVICE(PCAN_USB_VENDOR_ID
, PCAN_USB_PRODUCT_ID
)},
39 {USB_DEVICE(PCAN_USB_VENDOR_ID
, PCAN_USBPRO_PRODUCT_ID
)},
40 {} /* Terminating entry */
43 MODULE_DEVICE_TABLE(usb
, peak_usb_table
);
45 /* List of supported PCAN-USB adapters (NULL terminated list) */
46 static struct peak_usb_adapter
*peak_usb_adapters_list
[] = {
56 void pcan_dump_mem(char *prompt
, void *p
, int l
)
58 pr_info("%s dumping %s (%d bytes):\n",
59 PCAN_USB_DRIVER_NAME
, prompt
? prompt
: "memory", l
);
60 print_hex_dump(KERN_INFO
, PCAN_USB_DRIVER_NAME
" ", DUMP_PREFIX_NONE
,
61 DUMP_WIDTH
, 1, p
, l
, false);
65 * initialize a time_ref object with usb adapter own settings
67 void peak_usb_init_time_ref(struct peak_time_ref
*time_ref
,
68 struct peak_usb_adapter
*adapter
)
71 memset(time_ref
, 0, sizeof(struct peak_time_ref
));
72 time_ref
->adapter
= adapter
;
76 static void peak_usb_add_us(struct timeval
*tv
, u32 delta_us
)
78 /* number of s. to add to final time */
79 u32 delta_s
= delta_us
/ 1000000;
81 delta_us
-= delta_s
* 1000000;
83 tv
->tv_usec
+= delta_us
;
84 if (tv
->tv_usec
>= 1000000) {
85 tv
->tv_usec
-= 1000000;
88 tv
->tv_sec
+= delta_s
;
92 * sometimes, another now may be more recent than current one...
94 void peak_usb_update_ts_now(struct peak_time_ref
*time_ref
, u32 ts_now
)
96 time_ref
->ts_dev_2
= ts_now
;
98 /* should wait at least two passes before computing */
99 if (time_ref
->tv_host
.tv_sec
> 0) {
100 u32 delta_ts
= time_ref
->ts_dev_2
- time_ref
->ts_dev_1
;
102 if (time_ref
->ts_dev_2
< time_ref
->ts_dev_1
)
103 delta_ts
&= (1 << time_ref
->adapter
->ts_used_bits
) - 1;
105 time_ref
->ts_total
+= delta_ts
;
110 * register device timestamp as now
112 void peak_usb_set_ts_now(struct peak_time_ref
*time_ref
, u32 ts_now
)
114 if (time_ref
->tv_host_0
.tv_sec
== 0) {
115 /* use monotonic clock to correctly compute further deltas */
116 time_ref
->tv_host_0
= ktime_to_timeval(ktime_get());
117 time_ref
->tv_host
.tv_sec
= 0;
120 * delta_us should not be >= 2^32 => delta_s should be < 4294
121 * handle 32-bits wrapping here: if count of s. reaches 4200,
122 * reset counters and change time base
124 if (time_ref
->tv_host
.tv_sec
!= 0) {
125 u32 delta_s
= time_ref
->tv_host
.tv_sec
126 - time_ref
->tv_host_0
.tv_sec
;
127 if (delta_s
> 4200) {
128 time_ref
->tv_host_0
= time_ref
->tv_host
;
129 time_ref
->ts_total
= 0;
133 time_ref
->tv_host
= ktime_to_timeval(ktime_get());
134 time_ref
->tick_count
++;
137 time_ref
->ts_dev_1
= time_ref
->ts_dev_2
;
138 peak_usb_update_ts_now(time_ref
, ts_now
);
142 * compute timeval according to current ts and time_ref data
144 void peak_usb_get_ts_tv(struct peak_time_ref
*time_ref
, u32 ts
,
147 /* protect from getting timeval before setting now */
148 if (time_ref
->tv_host
.tv_sec
> 0) {
151 delta_us
= ts
- time_ref
->ts_dev_2
;
152 if (ts
< time_ref
->ts_dev_2
)
153 delta_us
&= (1 << time_ref
->adapter
->ts_used_bits
) - 1;
155 delta_us
+= time_ref
->ts_total
;
157 delta_us
*= time_ref
->adapter
->us_per_ts_scale
;
158 delta_us
>>= time_ref
->adapter
->us_per_ts_shift
;
160 *tv
= time_ref
->tv_host_0
;
161 peak_usb_add_us(tv
, (u32
)delta_us
);
163 *tv
= ktime_to_timeval(ktime_get());
168 * callback for bulk Rx urb
170 static void peak_usb_read_bulk_callback(struct urb
*urb
)
172 struct peak_usb_device
*dev
= urb
->context
;
173 struct net_device
*netdev
;
176 netdev
= dev
->netdev
;
178 if (!netif_device_present(netdev
))
181 /* check reception status */
182 switch (urb
->status
) {
196 "Rx urb aborted (%d)\n", urb
->status
);
200 /* protect from any incoming empty msgs */
201 if ((urb
->actual_length
> 0) && (dev
->adapter
->dev_decode_buf
)) {
202 /* handle these kinds of msgs only if _start callback called */
203 if (dev
->state
& PCAN_USB_STATE_STARTED
) {
204 err
= dev
->adapter
->dev_decode_buf(dev
, urb
);
206 pcan_dump_mem("received usb message",
207 urb
->transfer_buffer
,
208 urb
->transfer_buffer_length
);
213 usb_fill_bulk_urb(urb
, dev
->udev
,
214 usb_rcvbulkpipe(dev
->udev
, dev
->ep_msg_in
),
215 urb
->transfer_buffer
, dev
->adapter
->rx_buffer_size
,
216 peak_usb_read_bulk_callback
, dev
);
218 usb_anchor_urb(urb
, &dev
->rx_submitted
);
219 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
223 usb_unanchor_urb(urb
);
226 netif_device_detach(netdev
);
228 netdev_err(netdev
, "failed resubmitting read bulk urb: %d\n",
233 * callback for bulk Tx urb
235 static void peak_usb_write_bulk_callback(struct urb
*urb
)
237 struct peak_tx_urb_context
*context
= urb
->context
;
238 struct peak_usb_device
*dev
;
239 struct net_device
*netdev
;
244 netdev
= dev
->netdev
;
246 atomic_dec(&dev
->active_tx_urbs
);
248 if (!netif_device_present(netdev
))
251 /* check tx status */
252 switch (urb
->status
) {
254 /* transmission complete */
255 netdev
->stats
.tx_packets
++;
256 netdev
->stats
.tx_bytes
+= context
->dlc
;
258 /* prevent tx timeout */
259 netdev
->trans_start
= jiffies
;
264 netdev_err(netdev
, "Tx urb aborted (%d)\n",
274 /* should always release echo skb and corresponding context */
275 can_get_echo_skb(netdev
, context
->echo_index
);
276 context
->echo_index
= PCAN_USB_MAX_TX_URBS
;
278 /* do wakeup tx queue in case of success only */
280 netif_wake_queue(netdev
);
284 * called by netdev to send one skb on the CAN interface.
286 static netdev_tx_t
peak_usb_ndo_start_xmit(struct sk_buff
*skb
,
287 struct net_device
*netdev
)
289 struct peak_usb_device
*dev
= netdev_priv(netdev
);
290 struct peak_tx_urb_context
*context
= NULL
;
291 struct net_device_stats
*stats
= &netdev
->stats
;
292 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
296 size_t size
= dev
->adapter
->tx_buffer_size
;
298 if (can_dropped_invalid_skb(netdev
, skb
))
301 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++)
302 if (dev
->tx_contexts
[i
].echo_index
== PCAN_USB_MAX_TX_URBS
) {
303 context
= dev
->tx_contexts
+ i
;
308 /* should not occur except during restart */
309 return NETDEV_TX_BUSY
;
313 obuf
= urb
->transfer_buffer
;
315 err
= dev
->adapter
->dev_encode_msg(dev
, skb
, obuf
, &size
);
318 netdev_err(netdev
, "packet dropped\n");
324 context
->echo_index
= i
;
325 context
->dlc
= cf
->can_dlc
;
327 usb_anchor_urb(urb
, &dev
->tx_submitted
);
329 can_put_echo_skb(skb
, netdev
, context
->echo_index
);
331 atomic_inc(&dev
->active_tx_urbs
);
333 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
335 can_free_echo_skb(netdev
, context
->echo_index
);
337 usb_unanchor_urb(urb
);
339 /* this context is not used in fact */
340 context
->echo_index
= PCAN_USB_MAX_TX_URBS
;
342 atomic_dec(&dev
->active_tx_urbs
);
346 netif_device_detach(netdev
);
349 netdev_warn(netdev
, "tx urb submitting failed err=%d\n",
352 /* cable unplugged */
356 netdev
->trans_start
= jiffies
;
358 /* slow down tx path */
359 if (atomic_read(&dev
->active_tx_urbs
) >= PCAN_USB_MAX_TX_URBS
)
360 netif_stop_queue(netdev
);
367 * start the CAN interface.
368 * Rx and Tx urbs are allocated here. Rx urbs are submitted here.
370 static int peak_usb_start(struct peak_usb_device
*dev
)
372 struct net_device
*netdev
= dev
->netdev
;
375 for (i
= 0; i
< PCAN_USB_MAX_RX_URBS
; i
++) {
379 /* create a URB, and a buffer for it, to receive usb messages */
380 urb
= usb_alloc_urb(0, GFP_KERNEL
);
382 netdev_err(netdev
, "No memory left for URBs\n");
387 buf
= kmalloc(dev
->adapter
->rx_buffer_size
, GFP_KERNEL
);
389 netdev_err(netdev
, "No memory left for USB buffer\n");
395 usb_fill_bulk_urb(urb
, dev
->udev
,
396 usb_rcvbulkpipe(dev
->udev
, dev
->ep_msg_in
),
397 buf
, dev
->adapter
->rx_buffer_size
,
398 peak_usb_read_bulk_callback
, dev
);
400 /* ask last usb_free_urb() to also kfree() transfer_buffer */
401 urb
->transfer_flags
|= URB_FREE_BUFFER
;
402 usb_anchor_urb(urb
, &dev
->rx_submitted
);
404 err
= usb_submit_urb(urb
, GFP_KERNEL
);
407 netif_device_detach(dev
->netdev
);
409 usb_unanchor_urb(urb
);
415 /* drop reference, USB core will take care of freeing it */
419 /* did we submit any URBs? Warn if we was not able to submit all urbs */
420 if (i
< PCAN_USB_MAX_RX_URBS
) {
422 netdev_err(netdev
, "couldn't setup any rx URB\n");
426 netdev_warn(netdev
, "rx performance may be slow\n");
429 /* pre-alloc tx buffers and corresponding urbs */
430 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++) {
431 struct peak_tx_urb_context
*context
;
435 /* create a URB and a buffer for it, to transmit usb messages */
436 urb
= usb_alloc_urb(0, GFP_KERNEL
);
438 netdev_err(netdev
, "No memory left for URBs\n");
443 buf
= kmalloc(dev
->adapter
->tx_buffer_size
, GFP_KERNEL
);
445 netdev_err(netdev
, "No memory left for USB buffer\n");
451 context
= dev
->tx_contexts
+ i
;
455 usb_fill_bulk_urb(urb
, dev
->udev
,
456 usb_sndbulkpipe(dev
->udev
, dev
->ep_msg_out
),
457 buf
, dev
->adapter
->tx_buffer_size
,
458 peak_usb_write_bulk_callback
, context
);
460 /* ask last usb_free_urb() to also kfree() transfer_buffer */
461 urb
->transfer_flags
|= URB_FREE_BUFFER
;
464 /* warn if we were not able to allocate enough tx contexts */
465 if (i
< PCAN_USB_MAX_TX_URBS
) {
467 netdev_err(netdev
, "couldn't setup any tx URB\n");
471 netdev_warn(netdev
, "tx performance may be slow\n");
474 if (dev
->adapter
->dev_start
) {
475 err
= dev
->adapter
->dev_start(dev
);
480 dev
->state
|= PCAN_USB_STATE_STARTED
;
482 /* can set bus on now */
483 if (dev
->adapter
->dev_set_bus
) {
484 err
= dev
->adapter
->dev_set_bus(dev
, 1);
489 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
495 netif_device_detach(dev
->netdev
);
497 netdev_warn(netdev
, "couldn't submit control: %d\n", err
);
503 * called by netdev to open the corresponding CAN interface.
505 static int peak_usb_ndo_open(struct net_device
*netdev
)
507 struct peak_usb_device
*dev
= netdev_priv(netdev
);
511 err
= open_candev(netdev
);
515 /* finally start device */
516 err
= peak_usb_start(dev
);
518 netdev_err(netdev
, "couldn't start device: %d\n", err
);
519 close_candev(netdev
);
523 netif_start_queue(netdev
);
529 * unlink in-flight Rx and Tx urbs and free their memory.
531 static void peak_usb_unlink_all_urbs(struct peak_usb_device
*dev
)
535 /* free all Rx (submitted) urbs */
536 usb_kill_anchored_urbs(&dev
->rx_submitted
);
538 /* free unsubmitted Tx urbs first */
539 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++) {
540 struct urb
*urb
= dev
->tx_contexts
[i
].urb
;
543 dev
->tx_contexts
[i
].echo_index
!= PCAN_USB_MAX_TX_URBS
) {
545 * this urb is already released or always submitted,
546 * let usb core free by itself
552 dev
->tx_contexts
[i
].urb
= NULL
;
555 /* then free all submitted Tx urbs */
556 usb_kill_anchored_urbs(&dev
->tx_submitted
);
557 atomic_set(&dev
->active_tx_urbs
, 0);
561 * called by netdev to close the corresponding CAN interface.
563 static int peak_usb_ndo_stop(struct net_device
*netdev
)
565 struct peak_usb_device
*dev
= netdev_priv(netdev
);
567 dev
->state
&= ~PCAN_USB_STATE_STARTED
;
568 netif_stop_queue(netdev
);
570 /* unlink all pending urbs and free used memory */
571 peak_usb_unlink_all_urbs(dev
);
573 if (dev
->adapter
->dev_stop
)
574 dev
->adapter
->dev_stop(dev
);
576 close_candev(netdev
);
578 dev
->can
.state
= CAN_STATE_STOPPED
;
580 /* can set bus off now */
581 if (dev
->adapter
->dev_set_bus
) {
582 int err
= dev
->adapter
->dev_set_bus(dev
, 0);
591 * handle end of waiting for the device to reset
593 void peak_usb_restart_complete(struct peak_usb_device
*dev
)
595 /* finally MUST update can state */
596 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
598 /* netdev queue can be awaken now */
599 netif_wake_queue(dev
->netdev
);
602 void peak_usb_async_complete(struct urb
*urb
)
604 kfree(urb
->transfer_buffer
);
609 * device (auto-)restart mechanism runs in a timer context =>
610 * MUST handle restart with asynchronous usb transfers
612 static int peak_usb_restart(struct peak_usb_device
*dev
)
619 * if device doesn't define any asynchronous restart handler, simply
620 * wake the netdev queue up
622 if (!dev
->adapter
->dev_restart_async
) {
623 peak_usb_restart_complete(dev
);
627 /* first allocate a urb to handle the asynchronous steps */
628 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
630 netdev_err(dev
->netdev
, "no memory left for urb\n");
634 /* also allocate enough space for the commands to send */
635 buf
= kmalloc(PCAN_USB_MAX_CMD_LEN
, GFP_ATOMIC
);
637 netdev_err(dev
->netdev
, "no memory left for async cmd\n");
642 /* call the device specific handler for the restart */
643 err
= dev
->adapter
->dev_restart_async(dev
, urb
, buf
);
654 * candev callback used to change CAN mode.
655 * Warning: this is called from a timer context!
657 static int peak_usb_set_mode(struct net_device
*netdev
, enum can_mode mode
)
659 struct peak_usb_device
*dev
= netdev_priv(netdev
);
664 err
= peak_usb_restart(dev
);
666 netdev_err(netdev
, "couldn't start device (err %d)\n",
678 * candev callback used to set device bitrate.
680 static int peak_usb_set_bittiming(struct net_device
*netdev
)
682 struct peak_usb_device
*dev
= netdev_priv(netdev
);
683 struct can_bittiming
*bt
= &dev
->can
.bittiming
;
685 if (dev
->adapter
->dev_set_bittiming
) {
686 int err
= dev
->adapter
->dev_set_bittiming(dev
, bt
);
689 netdev_info(netdev
, "couldn't set bitrate (err %d)\n",
697 static const struct net_device_ops peak_usb_netdev_ops
= {
698 .ndo_open
= peak_usb_ndo_open
,
699 .ndo_stop
= peak_usb_ndo_stop
,
700 .ndo_start_xmit
= peak_usb_ndo_start_xmit
,
704 * create one device which is attached to CAN controller #ctrl_idx of the
707 static int peak_usb_create_dev(struct peak_usb_adapter
*peak_usb_adapter
,
708 struct usb_interface
*intf
, int ctrl_idx
)
710 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
711 int sizeof_candev
= peak_usb_adapter
->sizeof_dev_private
;
712 struct peak_usb_device
*dev
;
713 struct net_device
*netdev
;
717 if (sizeof_candev
< sizeof(struct peak_usb_device
))
718 sizeof_candev
= sizeof(struct peak_usb_device
);
720 netdev
= alloc_candev(sizeof_candev
, PCAN_USB_MAX_TX_URBS
);
722 dev_err(&intf
->dev
, "%s: couldn't alloc candev\n",
723 PCAN_USB_DRIVER_NAME
);
727 dev
= netdev_priv(netdev
);
729 /* allocate a buffer large enough to send commands */
730 dev
->cmd_buf
= kmalloc(PCAN_USB_MAX_CMD_LEN
, GFP_KERNEL
);
732 dev_err(&intf
->dev
, "%s: couldn't alloc cmd buffer\n",
733 PCAN_USB_DRIVER_NAME
);
735 goto lbl_set_intf_data
;
739 dev
->netdev
= netdev
;
740 dev
->adapter
= peak_usb_adapter
;
741 dev
->ctrl_idx
= ctrl_idx
;
742 dev
->state
= PCAN_USB_STATE_CONNECTED
;
744 dev
->ep_msg_in
= peak_usb_adapter
->ep_msg_in
;
745 dev
->ep_msg_out
= peak_usb_adapter
->ep_msg_out
[ctrl_idx
];
747 dev
->can
.clock
= peak_usb_adapter
->clock
;
748 dev
->can
.bittiming_const
= &peak_usb_adapter
->bittiming_const
;
749 dev
->can
.do_set_bittiming
= peak_usb_set_bittiming
;
750 dev
->can
.do_set_mode
= peak_usb_set_mode
;
751 dev
->can
.ctrlmode_supported
= CAN_CTRLMODE_3_SAMPLES
|
752 CAN_CTRLMODE_LISTENONLY
;
754 netdev
->netdev_ops
= &peak_usb_netdev_ops
;
756 netdev
->flags
|= IFF_ECHO
; /* we support local echo */
758 init_usb_anchor(&dev
->rx_submitted
);
760 init_usb_anchor(&dev
->tx_submitted
);
761 atomic_set(&dev
->active_tx_urbs
, 0);
763 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++)
764 dev
->tx_contexts
[i
].echo_index
= PCAN_USB_MAX_TX_URBS
;
766 dev
->prev_siblings
= usb_get_intfdata(intf
);
767 usb_set_intfdata(intf
, dev
);
769 SET_NETDEV_DEV(netdev
, &intf
->dev
);
771 err
= register_candev(netdev
);
773 dev_err(&intf
->dev
, "couldn't register CAN device: %d\n", err
);
774 goto lbl_free_cmd_buf
;
777 if (dev
->prev_siblings
)
778 (dev
->prev_siblings
)->next_siblings
= dev
;
780 /* keep hw revision into the netdevice */
781 tmp16
= le16_to_cpu(usb_dev
->descriptor
.bcdDevice
);
782 dev
->device_rev
= tmp16
>> 8;
784 if (dev
->adapter
->dev_init
) {
785 err
= dev
->adapter
->dev_init(dev
);
787 goto lbl_free_cmd_buf
;
791 if (dev
->adapter
->dev_set_bus
) {
792 err
= dev
->adapter
->dev_set_bus(dev
, 0);
794 goto lbl_free_cmd_buf
;
797 /* get device number early */
798 if (dev
->adapter
->dev_get_device_id
)
799 dev
->adapter
->dev_get_device_id(dev
, &dev
->device_number
);
801 netdev_info(netdev
, "attached to %s channel %u (device %u)\n",
802 peak_usb_adapter
->name
, ctrl_idx
, dev
->device_number
);
810 usb_set_intfdata(intf
, dev
->prev_siblings
);
817 * called by the usb core when the device is unplugged from the system
819 static void peak_usb_disconnect(struct usb_interface
*intf
)
821 struct peak_usb_device
*dev
;
823 /* unregister as many netdev devices as siblings */
824 for (dev
= usb_get_intfdata(intf
); dev
; dev
= dev
->prev_siblings
) {
825 struct net_device
*netdev
= dev
->netdev
;
828 dev
->state
&= ~PCAN_USB_STATE_CONNECTED
;
829 strncpy(name
, netdev
->name
, IFNAMSIZ
);
831 unregister_netdev(netdev
);
835 dev
->next_siblings
= NULL
;
836 if (dev
->adapter
->dev_free
)
837 dev
->adapter
->dev_free(dev
);
839 dev_info(&intf
->dev
, "%s removed\n", name
);
842 usb_set_intfdata(intf
, NULL
);
846 * probe function for new PEAK-System devices
848 static int peak_usb_probe(struct usb_interface
*intf
,
849 const struct usb_device_id
*id
)
851 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
852 struct peak_usb_adapter
*peak_usb_adapter
, **pp
;
853 int i
, err
= -ENOMEM
;
855 usb_dev
= interface_to_usbdev(intf
);
857 /* get corresponding PCAN-USB adapter */
858 for (pp
= peak_usb_adapters_list
; *pp
; pp
++)
859 if ((*pp
)->device_id
== usb_dev
->descriptor
.idProduct
)
862 peak_usb_adapter
= *pp
;
863 if (!peak_usb_adapter
) {
864 /* should never come except device_id bad usage in this file */
865 pr_err("%s: didn't find device id. 0x%x in devices list\n",
866 PCAN_USB_DRIVER_NAME
, usb_dev
->descriptor
.idProduct
);
870 /* got corresponding adapter: check if it handles current interface */
871 if (peak_usb_adapter
->intf_probe
) {
872 err
= peak_usb_adapter
->intf_probe(intf
);
877 for (i
= 0; i
< peak_usb_adapter
->ctrl_count
; i
++) {
878 err
= peak_usb_create_dev(peak_usb_adapter
, intf
, i
);
880 /* deregister already created devices */
881 peak_usb_disconnect(intf
);
889 /* usb specific object needed to register this driver with the usb subsystem */
890 static struct usb_driver peak_usb_driver
= {
891 .name
= PCAN_USB_DRIVER_NAME
,
892 .disconnect
= peak_usb_disconnect
,
893 .probe
= peak_usb_probe
,
894 .id_table
= peak_usb_table
,
897 static int __init
peak_usb_init(void)
901 /* register this driver with the USB subsystem */
902 err
= usb_register(&peak_usb_driver
);
904 pr_err("%s: usb_register failed (err %d)\n",
905 PCAN_USB_DRIVER_NAME
, err
);
910 static int peak_usb_do_device_exit(struct device
*d
, void *arg
)
912 struct usb_interface
*intf
= to_usb_interface(d
);
913 struct peak_usb_device
*dev
;
915 /* stop as many netdev devices as siblings */
916 for (dev
= usb_get_intfdata(intf
); dev
; dev
= dev
->prev_siblings
) {
917 struct net_device
*netdev
= dev
->netdev
;
919 if (netif_device_present(netdev
))
920 if (dev
->adapter
->dev_exit
)
921 dev
->adapter
->dev_exit(dev
);
927 static void __exit
peak_usb_exit(void)
931 /* last chance do send any synchronous commands here */
932 err
= driver_for_each_device(&peak_usb_driver
.drvwrap
.driver
, NULL
,
933 NULL
, peak_usb_do_device_exit
);
935 pr_err("%s: failed to stop all can devices (err %d)\n",
936 PCAN_USB_DRIVER_NAME
, err
);
938 /* deregister this driver with the USB subsystem */
939 usb_deregister(&peak_usb_driver
);
941 pr_info("%s: PCAN-USB interfaces driver unloaded\n",
942 PCAN_USB_DRIVER_NAME
);
945 module_init(peak_usb_init
);
946 module_exit(peak_usb_exit
);