1 // SPDX-License-Identifier: GPL-2.0
2 /* Parts of this driver are based on the following:
3 * - Kvaser linux leaf driver (version 4.78)
4 * - CAN driver for esd CAN-USB/2
5 * - Kvaser linux usbcanII driver (version 5.3)
6 * - Kvaser linux mhydra driver (version 5.24)
8 * Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved.
9 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
10 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
11 * Copyright (C) 2015 Valeo S.A.
14 #include <linux/completion.h>
15 #include <linux/device.h>
16 #include <linux/gfp.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/netdevice.h>
21 #include <linux/spinlock.h>
22 #include <linux/types.h>
23 #include <linux/usb.h>
25 #include <linux/can.h>
26 #include <linux/can/dev.h>
27 #include <linux/can/error.h>
28 #include <linux/can/netlink.h>
30 #include "kvaser_usb.h"
32 /* Kvaser USB vendor id. */
33 #define KVASER_VENDOR_ID 0x0bfd
35 /* Kvaser Leaf USB devices product ids */
36 #define USB_LEAF_DEVEL_PRODUCT_ID 10
37 #define USB_LEAF_LITE_PRODUCT_ID 11
38 #define USB_LEAF_PRO_PRODUCT_ID 12
39 #define USB_LEAF_SPRO_PRODUCT_ID 14
40 #define USB_LEAF_PRO_LS_PRODUCT_ID 15
41 #define USB_LEAF_PRO_SWC_PRODUCT_ID 16
42 #define USB_LEAF_PRO_LIN_PRODUCT_ID 17
43 #define USB_LEAF_SPRO_LS_PRODUCT_ID 18
44 #define USB_LEAF_SPRO_SWC_PRODUCT_ID 19
45 #define USB_MEMO2_DEVEL_PRODUCT_ID 22
46 #define USB_MEMO2_HSHS_PRODUCT_ID 23
47 #define USB_UPRO_HSHS_PRODUCT_ID 24
48 #define USB_LEAF_LITE_GI_PRODUCT_ID 25
49 #define USB_LEAF_PRO_OBDII_PRODUCT_ID 26
50 #define USB_MEMO2_HSLS_PRODUCT_ID 27
51 #define USB_LEAF_LITE_CH_PRODUCT_ID 28
52 #define USB_BLACKBIRD_SPRO_PRODUCT_ID 29
53 #define USB_OEM_MERCURY_PRODUCT_ID 34
54 #define USB_OEM_LEAF_PRODUCT_ID 35
55 #define USB_CAN_R_PRODUCT_ID 39
56 #define USB_LEAF_LITE_V2_PRODUCT_ID 288
57 #define USB_MINI_PCIE_HS_PRODUCT_ID 289
58 #define USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID 290
59 #define USB_USBCAN_LIGHT_2HS_PRODUCT_ID 291
60 #define USB_MINI_PCIE_2HS_PRODUCT_ID 292
61 #define USB_USBCAN_R_V2_PRODUCT_ID 294
62 #define USB_LEAF_LIGHT_R_V2_PRODUCT_ID 295
63 #define USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID 296
64 #define USB_LEAF_PRODUCT_ID_END \
65 USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID
67 /* Kvaser USBCan-II devices product ids */
68 #define USB_USBCAN_REVB_PRODUCT_ID 2
69 #define USB_VCI2_PRODUCT_ID 3
70 #define USB_USBCAN2_PRODUCT_ID 4
71 #define USB_MEMORATOR_PRODUCT_ID 5
73 /* Kvaser Minihydra USB devices product ids */
74 #define USB_BLACKBIRD_V2_PRODUCT_ID 258
75 #define USB_MEMO_PRO_5HS_PRODUCT_ID 260
76 #define USB_USBCAN_PRO_5HS_PRODUCT_ID 261
77 #define USB_USBCAN_LIGHT_4HS_PRODUCT_ID 262
78 #define USB_LEAF_PRO_HS_V2_PRODUCT_ID 263
79 #define USB_USBCAN_PRO_2HS_V2_PRODUCT_ID 264
80 #define USB_MEMO_2HS_PRODUCT_ID 265
81 #define USB_MEMO_PRO_2HS_V2_PRODUCT_ID 266
82 #define USB_HYBRID_CANLIN_PRODUCT_ID 267
83 #define USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID 268
84 #define USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID 269
85 #define USB_HYBRID_PRO_CANLIN_PRODUCT_ID 270
86 #define USB_U100_PRODUCT_ID 273
87 #define USB_U100P_PRODUCT_ID 274
88 #define USB_U100S_PRODUCT_ID 275
89 #define USB_HYDRA_PRODUCT_ID_END \
92 static inline bool kvaser_is_leaf(const struct usb_device_id *id)
94 return (id->idProduct >= USB_LEAF_DEVEL_PRODUCT_ID &&
95 id->idProduct <= USB_CAN_R_PRODUCT_ID) ||
96 (id->idProduct >= USB_LEAF_LITE_V2_PRODUCT_ID &&
97 id->idProduct <= USB_LEAF_PRODUCT_ID_END);
100 static inline bool kvaser_is_usbcan(const struct usb_device_id *id)
102 return id->idProduct >= USB_USBCAN_REVB_PRODUCT_ID &&
103 id->idProduct <= USB_MEMORATOR_PRODUCT_ID;
106 static inline bool kvaser_is_hydra(const struct usb_device_id *id)
108 return id->idProduct >= USB_BLACKBIRD_V2_PRODUCT_ID &&
109 id->idProduct <= USB_HYDRA_PRODUCT_ID_END;
112 static const struct usb_device_id kvaser_usb_table[] = {
113 /* Leaf USB product IDs */
114 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID) },
115 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID) },
116 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID),
117 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
118 KVASER_USB_HAS_SILENT_MODE },
119 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID),
120 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
121 KVASER_USB_HAS_SILENT_MODE },
122 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID),
123 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
124 KVASER_USB_HAS_SILENT_MODE },
125 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID),
126 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
127 KVASER_USB_HAS_SILENT_MODE },
128 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID),
129 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
130 KVASER_USB_HAS_SILENT_MODE },
131 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID),
132 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
133 KVASER_USB_HAS_SILENT_MODE },
134 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID),
135 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
136 KVASER_USB_HAS_SILENT_MODE },
137 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID),
138 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
139 KVASER_USB_HAS_SILENT_MODE },
140 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID),
141 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
142 KVASER_USB_HAS_SILENT_MODE },
143 { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID),
144 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
145 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID) },
146 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID),
147 .driver_info = KVASER_USB_HAS_TXRX_ERRORS |
148 KVASER_USB_HAS_SILENT_MODE },
149 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID),
150 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
151 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID),
152 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
153 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID),
154 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
155 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID),
156 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
157 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID),
158 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
159 { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID),
160 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
161 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID) },
162 { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID) },
163 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID) },
164 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID) },
165 { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID) },
166 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_R_V2_PRODUCT_ID) },
167 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_R_V2_PRODUCT_ID) },
168 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID) },
170 /* USBCANII USB product IDs */
171 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID),
172 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
173 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_REVB_PRODUCT_ID),
174 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
175 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMORATOR_PRODUCT_ID),
176 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
177 { USB_DEVICE(KVASER_VENDOR_ID, USB_VCI2_PRODUCT_ID),
178 .driver_info = KVASER_USB_HAS_TXRX_ERRORS },
180 /* Minihydra USB product IDs */
181 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_V2_PRODUCT_ID) },
182 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_5HS_PRODUCT_ID) },
183 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_5HS_PRODUCT_ID) },
184 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_4HS_PRODUCT_ID) },
185 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_HS_V2_PRODUCT_ID) },
186 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_2HS_V2_PRODUCT_ID) },
187 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_2HS_PRODUCT_ID) },
188 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_2HS_V2_PRODUCT_ID) },
189 { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_CANLIN_PRODUCT_ID) },
190 { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID) },
191 { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID) },
192 { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_CANLIN_PRODUCT_ID) },
193 { USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID) },
194 { USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID) },
195 { USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID) },
198 MODULE_DEVICE_TABLE(usb, kvaser_usb_table);
200 int kvaser_usb_send_cmd(const struct kvaser_usb *dev, void *cmd, int len)
202 int actual_len; /* Not used */
204 return usb_bulk_msg(dev->udev,
205 usb_sndbulkpipe(dev->udev,
206 dev->bulk_out->bEndpointAddress),
207 cmd, len, &actual_len, KVASER_USB_TIMEOUT);
210 int kvaser_usb_recv_cmd(const struct kvaser_usb *dev, void *cmd, int len,
213 return usb_bulk_msg(dev->udev,
214 usb_rcvbulkpipe(dev->udev,
215 dev->bulk_in->bEndpointAddress),
216 cmd, len, actual_len, KVASER_USB_TIMEOUT);
219 static void kvaser_usb_send_cmd_callback(struct urb *urb)
221 struct net_device *netdev = urb->context;
223 kfree(urb->transfer_buffer);
226 netdev_warn(netdev, "urb status received: %d\n", urb->status);
229 int kvaser_usb_send_cmd_async(struct kvaser_usb_net_priv *priv, void *cmd,
232 struct kvaser_usb *dev = priv->dev;
233 struct net_device *netdev = priv->netdev;
237 urb = usb_alloc_urb(0, GFP_ATOMIC);
241 usb_fill_bulk_urb(urb, dev->udev,
242 usb_sndbulkpipe(dev->udev,
243 dev->bulk_out->bEndpointAddress),
244 cmd, len, kvaser_usb_send_cmd_callback, netdev);
245 usb_anchor_urb(urb, &priv->tx_submitted);
247 err = usb_submit_urb(urb, GFP_ATOMIC);
249 netdev_err(netdev, "Error transmitting URB\n");
250 usb_unanchor_urb(urb);
257 int kvaser_usb_can_rx_over_error(struct net_device *netdev)
259 struct net_device_stats *stats = &netdev->stats;
260 struct can_frame *cf;
263 stats->rx_over_errors++;
266 skb = alloc_can_err_skb(netdev, &cf);
269 netdev_warn(netdev, "No memory left for err_skb\n");
273 cf->can_id |= CAN_ERR_CRTL;
274 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
277 stats->rx_bytes += cf->len;
283 static void kvaser_usb_read_bulk_callback(struct urb *urb)
285 struct kvaser_usb *dev = urb->context;
289 switch (urb->status) {
298 dev_info(&dev->intf->dev, "Rx URB aborted (%d)\n", urb->status);
302 dev->ops->dev_read_bulk_callback(dev, urb->transfer_buffer,
306 usb_fill_bulk_urb(urb, dev->udev,
307 usb_rcvbulkpipe(dev->udev,
308 dev->bulk_in->bEndpointAddress),
309 urb->transfer_buffer, KVASER_USB_RX_BUFFER_SIZE,
310 kvaser_usb_read_bulk_callback, dev);
312 err = usb_submit_urb(urb, GFP_ATOMIC);
313 if (err == -ENODEV) {
314 for (i = 0; i < dev->nchannels; i++) {
318 netif_device_detach(dev->nets[i]->netdev);
321 dev_err(&dev->intf->dev,
322 "Failed resubmitting read bulk urb: %d\n", err);
326 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev)
333 for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++) {
334 struct urb *urb = NULL;
338 urb = usb_alloc_urb(0, GFP_KERNEL);
344 buf = usb_alloc_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE,
345 GFP_KERNEL, &buf_dma);
347 dev_warn(&dev->intf->dev,
348 "No memory left for USB buffer\n");
354 usb_fill_bulk_urb(urb, dev->udev,
357 dev->bulk_in->bEndpointAddress),
358 buf, KVASER_USB_RX_BUFFER_SIZE,
359 kvaser_usb_read_bulk_callback, dev);
360 urb->transfer_dma = buf_dma;
361 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
362 usb_anchor_urb(urb, &dev->rx_submitted);
364 err = usb_submit_urb(urb, GFP_KERNEL);
366 usb_unanchor_urb(urb);
367 usb_free_coherent(dev->udev,
368 KVASER_USB_RX_BUFFER_SIZE, buf,
375 dev->rxbuf_dma[i] = buf_dma;
381 dev_warn(&dev->intf->dev, "Cannot setup read URBs, error %d\n",
384 } else if (i < KVASER_USB_MAX_RX_URBS) {
385 dev_warn(&dev->intf->dev, "RX performances may be slow\n");
388 dev->rxinitdone = true;
393 static int kvaser_usb_open(struct net_device *netdev)
395 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
396 struct kvaser_usb *dev = priv->dev;
399 err = open_candev(netdev);
403 err = kvaser_usb_setup_rx_urbs(dev);
407 err = dev->ops->dev_set_opt_mode(priv);
411 err = dev->ops->dev_start_chip(priv);
413 netdev_warn(netdev, "Cannot start device, error %d\n", err);
417 priv->can.state = CAN_STATE_ERROR_ACTIVE;
422 close_candev(netdev);
426 static void kvaser_usb_reset_tx_urb_contexts(struct kvaser_usb_net_priv *priv)
430 max_tx_urbs = priv->dev->max_tx_urbs;
432 priv->active_tx_contexts = 0;
433 for (i = 0; i < max_tx_urbs; i++)
434 priv->tx_contexts[i].echo_index = max_tx_urbs;
437 /* This method might sleep. Do not call it in the atomic context
438 * of URB completions.
440 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv)
442 usb_kill_anchored_urbs(&priv->tx_submitted);
443 kvaser_usb_reset_tx_urb_contexts(priv);
446 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev)
450 usb_kill_anchored_urbs(&dev->rx_submitted);
452 for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++)
453 usb_free_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE,
454 dev->rxbuf[i], dev->rxbuf_dma[i]);
456 for (i = 0; i < dev->nchannels; i++) {
457 struct kvaser_usb_net_priv *priv = dev->nets[i];
460 kvaser_usb_unlink_tx_urbs(priv);
464 static int kvaser_usb_close(struct net_device *netdev)
466 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
467 struct kvaser_usb *dev = priv->dev;
470 netif_stop_queue(netdev);
472 err = dev->ops->dev_flush_queue(priv);
474 netdev_warn(netdev, "Cannot flush queue, error %d\n", err);
476 if (dev->ops->dev_reset_chip) {
477 err = dev->ops->dev_reset_chip(dev, priv->channel);
479 netdev_warn(netdev, "Cannot reset card, error %d\n",
483 err = dev->ops->dev_stop_chip(priv);
485 netdev_warn(netdev, "Cannot stop device, error %d\n", err);
487 /* reset tx contexts */
488 kvaser_usb_unlink_tx_urbs(priv);
490 priv->can.state = CAN_STATE_STOPPED;
491 close_candev(priv->netdev);
496 static void kvaser_usb_write_bulk_callback(struct urb *urb)
498 struct kvaser_usb_tx_urb_context *context = urb->context;
499 struct kvaser_usb_net_priv *priv;
500 struct net_device *netdev;
502 if (WARN_ON(!context))
505 priv = context->priv;
506 netdev = priv->netdev;
508 kfree(urb->transfer_buffer);
510 if (!netif_device_present(netdev))
514 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
517 static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb,
518 struct net_device *netdev)
520 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
521 struct kvaser_usb *dev = priv->dev;
522 struct net_device_stats *stats = &netdev->stats;
523 struct kvaser_usb_tx_urb_context *context = NULL;
527 int err, ret = NETDEV_TX_OK;
531 if (can_dropped_invalid_skb(netdev, skb))
534 urb = usb_alloc_urb(0, GFP_ATOMIC);
541 spin_lock_irqsave(&priv->tx_contexts_lock, flags);
542 for (i = 0; i < dev->max_tx_urbs; i++) {
543 if (priv->tx_contexts[i].echo_index == dev->max_tx_urbs) {
544 context = &priv->tx_contexts[i];
546 context->echo_index = i;
547 ++priv->active_tx_contexts;
548 if (priv->active_tx_contexts >= (int)dev->max_tx_urbs)
549 netif_stop_queue(netdev);
554 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
556 /* This should never happen; it implies a flow control bug */
558 netdev_warn(netdev, "cannot find free context\n");
560 ret = NETDEV_TX_BUSY;
564 buf = dev->ops->dev_frame_to_cmd(priv, skb, &context->dlc, &cmd_len,
565 context->echo_index);
569 spin_lock_irqsave(&priv->tx_contexts_lock, flags);
571 context->echo_index = dev->max_tx_urbs;
572 --priv->active_tx_contexts;
573 netif_wake_queue(netdev);
575 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
579 context->priv = priv;
581 can_put_echo_skb(skb, netdev, context->echo_index, 0);
583 usb_fill_bulk_urb(urb, dev->udev,
584 usb_sndbulkpipe(dev->udev,
585 dev->bulk_out->bEndpointAddress),
586 buf, cmd_len, kvaser_usb_write_bulk_callback,
588 usb_anchor_urb(urb, &priv->tx_submitted);
590 err = usb_submit_urb(urb, GFP_ATOMIC);
592 spin_lock_irqsave(&priv->tx_contexts_lock, flags);
594 can_free_echo_skb(netdev, context->echo_index);
595 context->echo_index = dev->max_tx_urbs;
596 --priv->active_tx_contexts;
597 netif_wake_queue(netdev);
599 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
601 usb_unanchor_urb(urb);
607 netif_device_detach(netdev);
609 netdev_warn(netdev, "Failed tx_urb %d\n", err);
621 static const struct net_device_ops kvaser_usb_netdev_ops = {
622 .ndo_open = kvaser_usb_open,
623 .ndo_stop = kvaser_usb_close,
624 .ndo_start_xmit = kvaser_usb_start_xmit,
625 .ndo_change_mtu = can_change_mtu,
628 static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev)
632 for (i = 0; i < dev->nchannels; i++) {
636 unregister_candev(dev->nets[i]->netdev);
639 kvaser_usb_unlink_all_urbs(dev);
641 for (i = 0; i < dev->nchannels; i++) {
645 free_candev(dev->nets[i]->netdev);
649 static int kvaser_usb_init_one(struct kvaser_usb *dev,
650 const struct usb_device_id *id, int channel)
652 struct net_device *netdev;
653 struct kvaser_usb_net_priv *priv;
656 if (dev->ops->dev_reset_chip) {
657 err = dev->ops->dev_reset_chip(dev, channel);
662 netdev = alloc_candev(struct_size(priv, tx_contexts, dev->max_tx_urbs),
665 dev_err(&dev->intf->dev, "Cannot alloc candev\n");
669 priv = netdev_priv(netdev);
671 init_usb_anchor(&priv->tx_submitted);
672 init_completion(&priv->start_comp);
673 init_completion(&priv->stop_comp);
674 priv->can.ctrlmode_supported = 0;
677 priv->netdev = netdev;
678 priv->channel = channel;
680 spin_lock_init(&priv->tx_contexts_lock);
681 kvaser_usb_reset_tx_urb_contexts(priv);
683 priv->can.state = CAN_STATE_STOPPED;
684 priv->can.clock.freq = dev->cfg->clock.freq;
685 priv->can.bittiming_const = dev->cfg->bittiming_const;
686 priv->can.do_set_bittiming = dev->ops->dev_set_bittiming;
687 priv->can.do_set_mode = dev->ops->dev_set_mode;
688 if ((id->driver_info & KVASER_USB_HAS_TXRX_ERRORS) ||
689 (priv->dev->card_data.capabilities & KVASER_USB_CAP_BERR_CAP))
690 priv->can.do_get_berr_counter = dev->ops->dev_get_berr_counter;
691 if (id->driver_info & KVASER_USB_HAS_SILENT_MODE)
692 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
694 priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported;
696 if (priv->can.ctrlmode_supported & CAN_CTRLMODE_FD) {
697 priv->can.data_bittiming_const = dev->cfg->data_bittiming_const;
698 priv->can.do_set_data_bittiming =
699 dev->ops->dev_set_data_bittiming;
702 netdev->flags |= IFF_ECHO;
704 netdev->netdev_ops = &kvaser_usb_netdev_ops;
706 SET_NETDEV_DEV(netdev, &dev->intf->dev);
707 netdev->dev_id = channel;
709 dev->nets[channel] = priv;
711 err = register_candev(netdev);
713 dev_err(&dev->intf->dev, "Failed to register CAN device\n");
715 dev->nets[channel] = NULL;
719 netdev_dbg(netdev, "device registered\n");
724 static int kvaser_usb_probe(struct usb_interface *intf,
725 const struct usb_device_id *id)
727 struct kvaser_usb *dev;
731 dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL);
735 if (kvaser_is_leaf(id)) {
736 dev->card_data.leaf.family = KVASER_LEAF;
737 dev->ops = &kvaser_usb_leaf_dev_ops;
738 } else if (kvaser_is_usbcan(id)) {
739 dev->card_data.leaf.family = KVASER_USBCAN;
740 dev->ops = &kvaser_usb_leaf_dev_ops;
741 } else if (kvaser_is_hydra(id)) {
742 dev->ops = &kvaser_usb_hydra_dev_ops;
745 "Product ID (%d) is not a supported Kvaser USB device\n",
752 err = dev->ops->dev_setup_endpoints(dev);
754 dev_err(&intf->dev, "Cannot get usb endpoint(s)");
758 dev->udev = interface_to_usbdev(intf);
760 init_usb_anchor(&dev->rx_submitted);
762 usb_set_intfdata(intf, dev);
764 dev->card_data.ctrlmode_supported = 0;
765 dev->card_data.capabilities = 0;
766 err = dev->ops->dev_init_card(dev);
769 "Failed to initialize card, error %d\n", err);
773 err = dev->ops->dev_get_software_info(dev);
776 "Cannot get software info, error %d\n", err);
780 if (dev->ops->dev_get_software_details) {
781 err = dev->ops->dev_get_software_details(dev);
784 "Cannot get software details, error %d\n", err);
789 if (WARN_ON(!dev->cfg))
792 dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n",
793 ((dev->fw_version >> 24) & 0xff),
794 ((dev->fw_version >> 16) & 0xff),
795 (dev->fw_version & 0xffff));
797 dev_dbg(&intf->dev, "Max outstanding tx = %d URBs\n", dev->max_tx_urbs);
799 err = dev->ops->dev_get_card_info(dev);
801 dev_err(&intf->dev, "Cannot get card info, error %d\n", err);
805 if (dev->ops->dev_get_capabilities) {
806 err = dev->ops->dev_get_capabilities(dev);
809 "Cannot get capabilities, error %d\n", err);
810 kvaser_usb_remove_interfaces(dev);
815 for (i = 0; i < dev->nchannels; i++) {
816 err = kvaser_usb_init_one(dev, id, i);
818 kvaser_usb_remove_interfaces(dev);
826 static void kvaser_usb_disconnect(struct usb_interface *intf)
828 struct kvaser_usb *dev = usb_get_intfdata(intf);
830 usb_set_intfdata(intf, NULL);
835 kvaser_usb_remove_interfaces(dev);
838 static struct usb_driver kvaser_usb_driver = {
839 .name = "kvaser_usb",
840 .probe = kvaser_usb_probe,
841 .disconnect = kvaser_usb_disconnect,
842 .id_table = kvaser_usb_table,
845 module_usb_driver(kvaser_usb_driver);
847 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
848 MODULE_AUTHOR("Kvaser AB <support@kvaser.com>");
849 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
850 MODULE_LICENSE("GPL v2");