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 {USB_DEVICE(PCAN_USB_VENDOR_ID
, PCAN_USBFD_PRODUCT_ID
)},
41 {USB_DEVICE(PCAN_USB_VENDOR_ID
, PCAN_USBPROFD_PRODUCT_ID
)},
42 {} /* Terminating entry */
45 MODULE_DEVICE_TABLE(usb
, peak_usb_table
);
47 /* List of supported PCAN-USB adapters (NULL terminated list) */
48 static const struct peak_usb_adapter
*const peak_usb_adapters_list
[] = {
59 void pcan_dump_mem(char *prompt
, void *p
, int l
)
61 pr_info("%s dumping %s (%d bytes):\n",
62 PCAN_USB_DRIVER_NAME
, prompt
? prompt
: "memory", l
);
63 print_hex_dump(KERN_INFO
, PCAN_USB_DRIVER_NAME
" ", DUMP_PREFIX_NONE
,
64 DUMP_WIDTH
, 1, p
, l
, false);
68 * initialize a time_ref object with usb adapter own settings
70 void peak_usb_init_time_ref(struct peak_time_ref
*time_ref
,
71 const struct peak_usb_adapter
*adapter
)
74 memset(time_ref
, 0, sizeof(struct peak_time_ref
));
75 time_ref
->adapter
= adapter
;
79 static void peak_usb_add_us(struct timeval
*tv
, u32 delta_us
)
81 /* number of s. to add to final time */
82 u32 delta_s
= delta_us
/ 1000000;
84 delta_us
-= delta_s
* 1000000;
86 tv
->tv_usec
+= delta_us
;
87 if (tv
->tv_usec
>= 1000000) {
88 tv
->tv_usec
-= 1000000;
91 tv
->tv_sec
+= delta_s
;
95 * sometimes, another now may be more recent than current one...
97 void peak_usb_update_ts_now(struct peak_time_ref
*time_ref
, u32 ts_now
)
99 time_ref
->ts_dev_2
= ts_now
;
101 /* should wait at least two passes before computing */
102 if (time_ref
->tv_host
.tv_sec
> 0) {
103 u32 delta_ts
= time_ref
->ts_dev_2
- time_ref
->ts_dev_1
;
105 if (time_ref
->ts_dev_2
< time_ref
->ts_dev_1
)
106 delta_ts
&= (1 << time_ref
->adapter
->ts_used_bits
) - 1;
108 time_ref
->ts_total
+= delta_ts
;
113 * register device timestamp as now
115 void peak_usb_set_ts_now(struct peak_time_ref
*time_ref
, u32 ts_now
)
117 if (time_ref
->tv_host_0
.tv_sec
== 0) {
118 /* use monotonic clock to correctly compute further deltas */
119 time_ref
->tv_host_0
= ktime_to_timeval(ktime_get());
120 time_ref
->tv_host
.tv_sec
= 0;
123 * delta_us should not be >= 2^32 => delta_s should be < 4294
124 * handle 32-bits wrapping here: if count of s. reaches 4200,
125 * reset counters and change time base
127 if (time_ref
->tv_host
.tv_sec
!= 0) {
128 u32 delta_s
= time_ref
->tv_host
.tv_sec
129 - time_ref
->tv_host_0
.tv_sec
;
130 if (delta_s
> 4200) {
131 time_ref
->tv_host_0
= time_ref
->tv_host
;
132 time_ref
->ts_total
= 0;
136 time_ref
->tv_host
= ktime_to_timeval(ktime_get());
137 time_ref
->tick_count
++;
140 time_ref
->ts_dev_1
= time_ref
->ts_dev_2
;
141 peak_usb_update_ts_now(time_ref
, ts_now
);
145 * compute timeval according to current ts and time_ref data
147 void peak_usb_get_ts_tv(struct peak_time_ref
*time_ref
, u32 ts
,
150 /* protect from getting timeval before setting now */
151 if (time_ref
->tv_host
.tv_sec
> 0) {
154 delta_us
= ts
- time_ref
->ts_dev_2
;
155 if (ts
< time_ref
->ts_dev_2
)
156 delta_us
&= (1 << time_ref
->adapter
->ts_used_bits
) - 1;
158 delta_us
+= time_ref
->ts_total
;
160 delta_us
*= time_ref
->adapter
->us_per_ts_scale
;
161 delta_us
>>= time_ref
->adapter
->us_per_ts_shift
;
163 *tv
= time_ref
->tv_host_0
;
164 peak_usb_add_us(tv
, (u32
)delta_us
);
166 *tv
= ktime_to_timeval(ktime_get());
171 * post received skb after having set any hw timestamp
173 int peak_usb_netif_rx(struct sk_buff
*skb
,
174 struct peak_time_ref
*time_ref
, u32 ts_low
, u32 ts_high
)
176 struct skb_shared_hwtstamps
*hwts
= skb_hwtstamps(skb
);
179 peak_usb_get_ts_tv(time_ref
, ts_low
, &tv
);
180 hwts
->hwtstamp
= timeval_to_ktime(tv
);
182 return netif_rx(skb
);
186 * callback for bulk Rx urb
188 static void peak_usb_read_bulk_callback(struct urb
*urb
)
190 struct peak_usb_device
*dev
= urb
->context
;
191 struct net_device
*netdev
;
194 netdev
= dev
->netdev
;
196 if (!netif_device_present(netdev
))
199 /* check reception status */
200 switch (urb
->status
) {
214 "Rx urb aborted (%d)\n", urb
->status
);
218 /* protect from any incoming empty msgs */
219 if ((urb
->actual_length
> 0) && (dev
->adapter
->dev_decode_buf
)) {
220 /* handle these kinds of msgs only if _start callback called */
221 if (dev
->state
& PCAN_USB_STATE_STARTED
) {
222 err
= dev
->adapter
->dev_decode_buf(dev
, urb
);
224 pcan_dump_mem("received usb message",
225 urb
->transfer_buffer
,
226 urb
->transfer_buffer_length
);
231 usb_fill_bulk_urb(urb
, dev
->udev
,
232 usb_rcvbulkpipe(dev
->udev
, dev
->ep_msg_in
),
233 urb
->transfer_buffer
, dev
->adapter
->rx_buffer_size
,
234 peak_usb_read_bulk_callback
, dev
);
236 usb_anchor_urb(urb
, &dev
->rx_submitted
);
237 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
241 usb_unanchor_urb(urb
);
244 netif_device_detach(netdev
);
246 netdev_err(netdev
, "failed resubmitting read bulk urb: %d\n",
251 * callback for bulk Tx urb
253 static void peak_usb_write_bulk_callback(struct urb
*urb
)
255 struct peak_tx_urb_context
*context
= urb
->context
;
256 struct peak_usb_device
*dev
;
257 struct net_device
*netdev
;
262 netdev
= dev
->netdev
;
264 atomic_dec(&dev
->active_tx_urbs
);
266 if (!netif_device_present(netdev
))
269 /* check tx status */
270 switch (urb
->status
) {
272 /* transmission complete */
273 netdev
->stats
.tx_packets
++;
274 netdev
->stats
.tx_bytes
+= context
->data_len
;
276 /* prevent tx timeout */
277 netif_trans_update(netdev
);
282 netdev_err(netdev
, "Tx urb aborted (%d)\n",
292 /* should always release echo skb and corresponding context */
293 can_get_echo_skb(netdev
, context
->echo_index
);
294 context
->echo_index
= PCAN_USB_MAX_TX_URBS
;
296 /* do wakeup tx queue in case of success only */
298 netif_wake_queue(netdev
);
302 * called by netdev to send one skb on the CAN interface.
304 static netdev_tx_t
peak_usb_ndo_start_xmit(struct sk_buff
*skb
,
305 struct net_device
*netdev
)
307 struct peak_usb_device
*dev
= netdev_priv(netdev
);
308 struct peak_tx_urb_context
*context
= NULL
;
309 struct net_device_stats
*stats
= &netdev
->stats
;
310 struct canfd_frame
*cfd
= (struct canfd_frame
*)skb
->data
;
314 size_t size
= dev
->adapter
->tx_buffer_size
;
316 if (can_dropped_invalid_skb(netdev
, skb
))
319 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++)
320 if (dev
->tx_contexts
[i
].echo_index
== PCAN_USB_MAX_TX_URBS
) {
321 context
= dev
->tx_contexts
+ i
;
326 /* should not occur except during restart */
327 return NETDEV_TX_BUSY
;
331 obuf
= urb
->transfer_buffer
;
333 err
= dev
->adapter
->dev_encode_msg(dev
, skb
, obuf
, &size
);
336 netdev_err(netdev
, "packet dropped\n");
342 context
->echo_index
= i
;
344 /* Note: this works with CANFD frames too */
345 context
->data_len
= cfd
->len
;
347 usb_anchor_urb(urb
, &dev
->tx_submitted
);
349 can_put_echo_skb(skb
, netdev
, context
->echo_index
);
351 atomic_inc(&dev
->active_tx_urbs
);
353 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
355 can_free_echo_skb(netdev
, context
->echo_index
);
357 usb_unanchor_urb(urb
);
359 /* this context is not used in fact */
360 context
->echo_index
= PCAN_USB_MAX_TX_URBS
;
362 atomic_dec(&dev
->active_tx_urbs
);
366 netif_device_detach(netdev
);
369 netdev_warn(netdev
, "tx urb submitting failed err=%d\n",
372 /* cable unplugged */
376 netif_trans_update(netdev
);
378 /* slow down tx path */
379 if (atomic_read(&dev
->active_tx_urbs
) >= PCAN_USB_MAX_TX_URBS
)
380 netif_stop_queue(netdev
);
387 * start the CAN interface.
388 * Rx and Tx urbs are allocated here. Rx urbs are submitted here.
390 static int peak_usb_start(struct peak_usb_device
*dev
)
392 struct net_device
*netdev
= dev
->netdev
;
395 for (i
= 0; i
< PCAN_USB_MAX_RX_URBS
; i
++) {
399 /* create a URB, and a buffer for it, to receive usb messages */
400 urb
= usb_alloc_urb(0, GFP_KERNEL
);
402 netdev_err(netdev
, "No memory left for URBs\n");
407 buf
= kmalloc(dev
->adapter
->rx_buffer_size
, GFP_KERNEL
);
414 usb_fill_bulk_urb(urb
, dev
->udev
,
415 usb_rcvbulkpipe(dev
->udev
, dev
->ep_msg_in
),
416 buf
, dev
->adapter
->rx_buffer_size
,
417 peak_usb_read_bulk_callback
, dev
);
419 /* ask last usb_free_urb() to also kfree() transfer_buffer */
420 urb
->transfer_flags
|= URB_FREE_BUFFER
;
421 usb_anchor_urb(urb
, &dev
->rx_submitted
);
423 err
= usb_submit_urb(urb
, GFP_KERNEL
);
426 netif_device_detach(dev
->netdev
);
428 usb_unanchor_urb(urb
);
434 /* drop reference, USB core will take care of freeing it */
438 /* did we submit any URBs? Warn if we was not able to submit all urbs */
439 if (i
< PCAN_USB_MAX_RX_URBS
) {
441 netdev_err(netdev
, "couldn't setup any rx URB\n");
445 netdev_warn(netdev
, "rx performance may be slow\n");
448 /* pre-alloc tx buffers and corresponding urbs */
449 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++) {
450 struct peak_tx_urb_context
*context
;
454 /* create a URB and a buffer for it, to transmit usb messages */
455 urb
= usb_alloc_urb(0, GFP_KERNEL
);
457 netdev_err(netdev
, "No memory left for URBs\n");
462 buf
= kmalloc(dev
->adapter
->tx_buffer_size
, GFP_KERNEL
);
469 context
= dev
->tx_contexts
+ i
;
473 usb_fill_bulk_urb(urb
, dev
->udev
,
474 usb_sndbulkpipe(dev
->udev
, dev
->ep_msg_out
),
475 buf
, dev
->adapter
->tx_buffer_size
,
476 peak_usb_write_bulk_callback
, context
);
478 /* ask last usb_free_urb() to also kfree() transfer_buffer */
479 urb
->transfer_flags
|= URB_FREE_BUFFER
;
482 /* warn if we were not able to allocate enough tx contexts */
483 if (i
< PCAN_USB_MAX_TX_URBS
) {
485 netdev_err(netdev
, "couldn't setup any tx URB\n");
489 netdev_warn(netdev
, "tx performance may be slow\n");
492 if (dev
->adapter
->dev_start
) {
493 err
= dev
->adapter
->dev_start(dev
);
498 dev
->state
|= PCAN_USB_STATE_STARTED
;
500 /* can set bus on now */
501 if (dev
->adapter
->dev_set_bus
) {
502 err
= dev
->adapter
->dev_set_bus(dev
, 1);
507 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
513 netif_device_detach(dev
->netdev
);
515 netdev_warn(netdev
, "couldn't submit control: %d\n", err
);
517 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++) {
518 usb_free_urb(dev
->tx_contexts
[i
].urb
);
519 dev
->tx_contexts
[i
].urb
= NULL
;
522 usb_kill_anchored_urbs(&dev
->rx_submitted
);
528 * called by netdev to open the corresponding CAN interface.
530 static int peak_usb_ndo_open(struct net_device
*netdev
)
532 struct peak_usb_device
*dev
= netdev_priv(netdev
);
536 err
= open_candev(netdev
);
540 /* finally start device */
541 err
= peak_usb_start(dev
);
543 netdev_err(netdev
, "couldn't start device: %d\n", err
);
544 close_candev(netdev
);
548 netif_start_queue(netdev
);
554 * unlink in-flight Rx and Tx urbs and free their memory.
556 static void peak_usb_unlink_all_urbs(struct peak_usb_device
*dev
)
560 /* free all Rx (submitted) urbs */
561 usb_kill_anchored_urbs(&dev
->rx_submitted
);
563 /* free unsubmitted Tx urbs first */
564 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++) {
565 struct urb
*urb
= dev
->tx_contexts
[i
].urb
;
568 dev
->tx_contexts
[i
].echo_index
!= PCAN_USB_MAX_TX_URBS
) {
570 * this urb is already released or always submitted,
571 * let usb core free by itself
577 dev
->tx_contexts
[i
].urb
= NULL
;
580 /* then free all submitted Tx urbs */
581 usb_kill_anchored_urbs(&dev
->tx_submitted
);
582 atomic_set(&dev
->active_tx_urbs
, 0);
586 * called by netdev to close the corresponding CAN interface.
588 static int peak_usb_ndo_stop(struct net_device
*netdev
)
590 struct peak_usb_device
*dev
= netdev_priv(netdev
);
592 dev
->state
&= ~PCAN_USB_STATE_STARTED
;
593 netif_stop_queue(netdev
);
595 /* unlink all pending urbs and free used memory */
596 peak_usb_unlink_all_urbs(dev
);
598 if (dev
->adapter
->dev_stop
)
599 dev
->adapter
->dev_stop(dev
);
601 close_candev(netdev
);
603 dev
->can
.state
= CAN_STATE_STOPPED
;
605 /* can set bus off now */
606 if (dev
->adapter
->dev_set_bus
) {
607 int err
= dev
->adapter
->dev_set_bus(dev
, 0);
616 * handle end of waiting for the device to reset
618 void peak_usb_restart_complete(struct peak_usb_device
*dev
)
620 /* finally MUST update can state */
621 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
623 /* netdev queue can be awaken now */
624 netif_wake_queue(dev
->netdev
);
627 void peak_usb_async_complete(struct urb
*urb
)
629 kfree(urb
->transfer_buffer
);
634 * device (auto-)restart mechanism runs in a timer context =>
635 * MUST handle restart with asynchronous usb transfers
637 static int peak_usb_restart(struct peak_usb_device
*dev
)
644 * if device doesn't define any asynchronous restart handler, simply
645 * wake the netdev queue up
647 if (!dev
->adapter
->dev_restart_async
) {
648 peak_usb_restart_complete(dev
);
652 /* first allocate a urb to handle the asynchronous steps */
653 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
655 netdev_err(dev
->netdev
, "no memory left for urb\n");
659 /* also allocate enough space for the commands to send */
660 buf
= kmalloc(PCAN_USB_MAX_CMD_LEN
, GFP_ATOMIC
);
666 /* call the device specific handler for the restart */
667 err
= dev
->adapter
->dev_restart_async(dev
, urb
, buf
);
678 * candev callback used to change CAN mode.
679 * Warning: this is called from a timer context!
681 static int peak_usb_set_mode(struct net_device
*netdev
, enum can_mode mode
)
683 struct peak_usb_device
*dev
= netdev_priv(netdev
);
688 err
= peak_usb_restart(dev
);
690 netdev_err(netdev
, "couldn't start device (err %d)\n",
702 * candev callback used to set device nominal/arbitration bitrate.
704 static int peak_usb_set_bittiming(struct net_device
*netdev
)
706 struct peak_usb_device
*dev
= netdev_priv(netdev
);
707 const struct peak_usb_adapter
*pa
= dev
->adapter
;
709 if (pa
->dev_set_bittiming
) {
710 struct can_bittiming
*bt
= &dev
->can
.bittiming
;
711 int err
= pa
->dev_set_bittiming(dev
, bt
);
714 netdev_info(netdev
, "couldn't set bitrate (err %d)\n",
723 * candev callback used to set device data bitrate.
725 static int peak_usb_set_data_bittiming(struct net_device
*netdev
)
727 struct peak_usb_device
*dev
= netdev_priv(netdev
);
728 const struct peak_usb_adapter
*pa
= dev
->adapter
;
730 if (pa
->dev_set_data_bittiming
) {
731 struct can_bittiming
*bt
= &dev
->can
.data_bittiming
;
732 int err
= pa
->dev_set_data_bittiming(dev
, bt
);
736 "couldn't set data bitrate (err %d)\n",
745 static const struct net_device_ops peak_usb_netdev_ops
= {
746 .ndo_open
= peak_usb_ndo_open
,
747 .ndo_stop
= peak_usb_ndo_stop
,
748 .ndo_start_xmit
= peak_usb_ndo_start_xmit
,
749 .ndo_change_mtu
= can_change_mtu
,
753 * create one device which is attached to CAN controller #ctrl_idx of the
756 static int peak_usb_create_dev(const struct peak_usb_adapter
*peak_usb_adapter
,
757 struct usb_interface
*intf
, int ctrl_idx
)
759 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
760 int sizeof_candev
= peak_usb_adapter
->sizeof_dev_private
;
761 struct peak_usb_device
*dev
;
762 struct net_device
*netdev
;
766 if (sizeof_candev
< sizeof(struct peak_usb_device
))
767 sizeof_candev
= sizeof(struct peak_usb_device
);
769 netdev
= alloc_candev(sizeof_candev
, PCAN_USB_MAX_TX_URBS
);
771 dev_err(&intf
->dev
, "%s: couldn't alloc candev\n",
772 PCAN_USB_DRIVER_NAME
);
776 dev
= netdev_priv(netdev
);
778 /* allocate a buffer large enough to send commands */
779 dev
->cmd_buf
= kmalloc(PCAN_USB_MAX_CMD_LEN
, GFP_KERNEL
);
782 goto lbl_free_candev
;
786 dev
->netdev
= netdev
;
787 dev
->adapter
= peak_usb_adapter
;
788 dev
->ctrl_idx
= ctrl_idx
;
789 dev
->state
= PCAN_USB_STATE_CONNECTED
;
791 dev
->ep_msg_in
= peak_usb_adapter
->ep_msg_in
;
792 dev
->ep_msg_out
= peak_usb_adapter
->ep_msg_out
[ctrl_idx
];
794 dev
->can
.clock
= peak_usb_adapter
->clock
;
795 dev
->can
.bittiming_const
= peak_usb_adapter
->bittiming_const
;
796 dev
->can
.do_set_bittiming
= peak_usb_set_bittiming
;
797 dev
->can
.data_bittiming_const
= peak_usb_adapter
->data_bittiming_const
;
798 dev
->can
.do_set_data_bittiming
= peak_usb_set_data_bittiming
;
799 dev
->can
.do_set_mode
= peak_usb_set_mode
;
800 dev
->can
.do_get_berr_counter
= peak_usb_adapter
->do_get_berr_counter
;
801 dev
->can
.ctrlmode_supported
= peak_usb_adapter
->ctrlmode_supported
;
803 netdev
->netdev_ops
= &peak_usb_netdev_ops
;
805 netdev
->flags
|= IFF_ECHO
; /* we support local echo */
807 init_usb_anchor(&dev
->rx_submitted
);
809 init_usb_anchor(&dev
->tx_submitted
);
810 atomic_set(&dev
->active_tx_urbs
, 0);
812 for (i
= 0; i
< PCAN_USB_MAX_TX_URBS
; i
++)
813 dev
->tx_contexts
[i
].echo_index
= PCAN_USB_MAX_TX_URBS
;
815 dev
->prev_siblings
= usb_get_intfdata(intf
);
816 usb_set_intfdata(intf
, dev
);
818 SET_NETDEV_DEV(netdev
, &intf
->dev
);
819 netdev
->dev_id
= ctrl_idx
;
821 err
= register_candev(netdev
);
823 dev_err(&intf
->dev
, "couldn't register CAN device: %d\n", err
);
824 goto lbl_restore_intf_data
;
827 if (dev
->prev_siblings
)
828 (dev
->prev_siblings
)->next_siblings
= dev
;
830 /* keep hw revision into the netdevice */
831 tmp16
= le16_to_cpu(usb_dev
->descriptor
.bcdDevice
);
832 dev
->device_rev
= tmp16
>> 8;
834 if (dev
->adapter
->dev_init
) {
835 err
= dev
->adapter
->dev_init(dev
);
837 goto lbl_unregister_candev
;
841 if (dev
->adapter
->dev_set_bus
) {
842 err
= dev
->adapter
->dev_set_bus(dev
, 0);
844 goto lbl_unregister_candev
;
847 /* get device number early */
848 if (dev
->adapter
->dev_get_device_id
)
849 dev
->adapter
->dev_get_device_id(dev
, &dev
->device_number
);
851 netdev_info(netdev
, "attached to %s channel %u (device %u)\n",
852 peak_usb_adapter
->name
, ctrl_idx
, dev
->device_number
);
856 lbl_unregister_candev
:
857 unregister_candev(netdev
);
859 lbl_restore_intf_data
:
860 usb_set_intfdata(intf
, dev
->prev_siblings
);
870 * called by the usb core when the device is unplugged from the system
872 static void peak_usb_disconnect(struct usb_interface
*intf
)
874 struct peak_usb_device
*dev
;
876 /* unregister as many netdev devices as siblings */
877 for (dev
= usb_get_intfdata(intf
); dev
; dev
= dev
->prev_siblings
) {
878 struct net_device
*netdev
= dev
->netdev
;
881 dev
->state
&= ~PCAN_USB_STATE_CONNECTED
;
882 strncpy(name
, netdev
->name
, IFNAMSIZ
);
884 unregister_netdev(netdev
);
888 dev
->next_siblings
= NULL
;
889 if (dev
->adapter
->dev_free
)
890 dev
->adapter
->dev_free(dev
);
892 dev_info(&intf
->dev
, "%s removed\n", name
);
895 usb_set_intfdata(intf
, NULL
);
899 * probe function for new PEAK-System devices
901 static int peak_usb_probe(struct usb_interface
*intf
,
902 const struct usb_device_id
*id
)
904 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
905 const u16 usb_id_product
= le16_to_cpu(usb_dev
->descriptor
.idProduct
);
906 const struct peak_usb_adapter
*peak_usb_adapter
= NULL
;
907 int i
, err
= -ENOMEM
;
909 usb_dev
= interface_to_usbdev(intf
);
911 /* get corresponding PCAN-USB adapter */
912 for (i
= 0; i
< ARRAY_SIZE(peak_usb_adapters_list
); i
++)
913 if (peak_usb_adapters_list
[i
]->device_id
== usb_id_product
) {
914 peak_usb_adapter
= peak_usb_adapters_list
[i
];
918 if (!peak_usb_adapter
) {
919 /* should never come except device_id bad usage in this file */
920 pr_err("%s: didn't find device id. 0x%x in devices list\n",
921 PCAN_USB_DRIVER_NAME
, usb_dev
->descriptor
.idProduct
);
925 /* got corresponding adapter: check if it handles current interface */
926 if (peak_usb_adapter
->intf_probe
) {
927 err
= peak_usb_adapter
->intf_probe(intf
);
932 for (i
= 0; i
< peak_usb_adapter
->ctrl_count
; i
++) {
933 err
= peak_usb_create_dev(peak_usb_adapter
, intf
, i
);
935 /* deregister already created devices */
936 peak_usb_disconnect(intf
);
944 /* usb specific object needed to register this driver with the usb subsystem */
945 static struct usb_driver peak_usb_driver
= {
946 .name
= PCAN_USB_DRIVER_NAME
,
947 .disconnect
= peak_usb_disconnect
,
948 .probe
= peak_usb_probe
,
949 .id_table
= peak_usb_table
,
952 static int __init
peak_usb_init(void)
956 /* register this driver with the USB subsystem */
957 err
= usb_register(&peak_usb_driver
);
959 pr_err("%s: usb_register failed (err %d)\n",
960 PCAN_USB_DRIVER_NAME
, err
);
965 static int peak_usb_do_device_exit(struct device
*d
, void *arg
)
967 struct usb_interface
*intf
= to_usb_interface(d
);
968 struct peak_usb_device
*dev
;
970 /* stop as many netdev devices as siblings */
971 for (dev
= usb_get_intfdata(intf
); dev
; dev
= dev
->prev_siblings
) {
972 struct net_device
*netdev
= dev
->netdev
;
974 if (netif_device_present(netdev
))
975 if (dev
->adapter
->dev_exit
)
976 dev
->adapter
->dev_exit(dev
);
982 static void __exit
peak_usb_exit(void)
986 /* last chance do send any synchronous commands here */
987 err
= driver_for_each_device(&peak_usb_driver
.drvwrap
.driver
, NULL
,
988 NULL
, peak_usb_do_device_exit
);
990 pr_err("%s: failed to stop all can devices (err %d)\n",
991 PCAN_USB_DRIVER_NAME
, err
);
993 /* deregister this driver with the USB subsystem */
994 usb_deregister(&peak_usb_driver
);
996 pr_info("%s: PCAN-USB interfaces driver unloaded\n",
997 PCAN_USB_DRIVER_NAME
);
1000 module_init(peak_usb_init
);
1001 module_exit(peak_usb_exit
);