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) 7 * 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. 12 */ 13 14 #include <linux/completion.h> 15 #include <linux/device.h> 16 #include <linux/ethtool.h> 17 #include <linux/gfp.h> 18 #include <linux/if.h> 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/netdevice.h> 22 #include <linux/spinlock.h> 23 #include <linux/types.h> 24 #include <linux/usb.h> 25 26 #include <linux/can.h> 27 #include <linux/can/dev.h> 28 #include <linux/can/error.h> 29 #include <linux/can/netlink.h> 30 31 #include "kvaser_usb.h" 32 33 /* Kvaser USB vendor id. */ 34 #define KVASER_VENDOR_ID 0x0bfd 35 36 /* Kvaser Leaf USB devices product ids */ 37 #define USB_LEAF_DEVEL_PRODUCT_ID 10 38 #define USB_LEAF_LITE_PRODUCT_ID 11 39 #define USB_LEAF_PRO_PRODUCT_ID 12 40 #define USB_LEAF_SPRO_PRODUCT_ID 14 41 #define USB_LEAF_PRO_LS_PRODUCT_ID 15 42 #define USB_LEAF_PRO_SWC_PRODUCT_ID 16 43 #define USB_LEAF_PRO_LIN_PRODUCT_ID 17 44 #define USB_LEAF_SPRO_LS_PRODUCT_ID 18 45 #define USB_LEAF_SPRO_SWC_PRODUCT_ID 19 46 #define USB_MEMO2_DEVEL_PRODUCT_ID 22 47 #define USB_MEMO2_HSHS_PRODUCT_ID 23 48 #define USB_UPRO_HSHS_PRODUCT_ID 24 49 #define USB_LEAF_LITE_GI_PRODUCT_ID 25 50 #define USB_LEAF_PRO_OBDII_PRODUCT_ID 26 51 #define USB_MEMO2_HSLS_PRODUCT_ID 27 52 #define USB_LEAF_LITE_CH_PRODUCT_ID 28 53 #define USB_BLACKBIRD_SPRO_PRODUCT_ID 29 54 #define USB_OEM_MERCURY_PRODUCT_ID 34 55 #define USB_OEM_LEAF_PRODUCT_ID 35 56 #define USB_CAN_R_PRODUCT_ID 39 57 #define USB_LEAF_LITE_V2_PRODUCT_ID 288 58 #define USB_MINI_PCIE_HS_PRODUCT_ID 289 59 #define USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID 290 60 #define USB_USBCAN_LIGHT_2HS_PRODUCT_ID 291 61 #define USB_MINI_PCIE_2HS_PRODUCT_ID 292 62 #define USB_USBCAN_R_V2_PRODUCT_ID 294 63 #define USB_LEAF_LIGHT_R_V2_PRODUCT_ID 295 64 #define USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID 296 65 66 /* Kvaser USBCan-II devices product ids */ 67 #define USB_USBCAN_REVB_PRODUCT_ID 2 68 #define USB_VCI2_PRODUCT_ID 3 69 #define USB_USBCAN2_PRODUCT_ID 4 70 #define USB_MEMORATOR_PRODUCT_ID 5 71 72 /* Kvaser Minihydra USB devices product ids */ 73 #define USB_BLACKBIRD_V2_PRODUCT_ID 258 74 #define USB_MEMO_PRO_5HS_PRODUCT_ID 260 75 #define USB_USBCAN_PRO_5HS_PRODUCT_ID 261 76 #define USB_USBCAN_LIGHT_4HS_PRODUCT_ID 262 77 #define USB_LEAF_PRO_HS_V2_PRODUCT_ID 263 78 #define USB_USBCAN_PRO_2HS_V2_PRODUCT_ID 264 79 #define USB_MEMO_2HS_PRODUCT_ID 265 80 #define USB_MEMO_PRO_2HS_V2_PRODUCT_ID 266 81 #define USB_HYBRID_2CANLIN_PRODUCT_ID 267 82 #define USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID 268 83 #define USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID 269 84 #define USB_HYBRID_PRO_2CANLIN_PRODUCT_ID 270 85 #define USB_U100_PRODUCT_ID 273 86 #define USB_U100P_PRODUCT_ID 274 87 #define USB_U100S_PRODUCT_ID 275 88 #define USB_USBCAN_PRO_4HS_PRODUCT_ID 276 89 #define USB_HYBRID_CANLIN_PRODUCT_ID 277 90 #define USB_HYBRID_PRO_CANLIN_PRODUCT_ID 278 91 92 static const struct kvaser_usb_driver_info kvaser_usb_driver_info_hydra = { 93 .quirks = KVASER_USB_QUIRK_HAS_HARDWARE_TIMESTAMP, 94 .ops = &kvaser_usb_hydra_dev_ops, 95 }; 96 97 static const struct kvaser_usb_driver_info kvaser_usb_driver_info_usbcan = { 98 .quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | 99 KVASER_USB_QUIRK_HAS_SILENT_MODE, 100 .family = KVASER_USBCAN, 101 .ops = &kvaser_usb_leaf_dev_ops, 102 }; 103 104 static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf = { 105 .quirks = KVASER_USB_QUIRK_IGNORE_CLK_FREQ, 106 .family = KVASER_LEAF, 107 .ops = &kvaser_usb_leaf_dev_ops, 108 }; 109 110 static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err = { 111 .quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | 112 KVASER_USB_QUIRK_IGNORE_CLK_FREQ, 113 .family = KVASER_LEAF, 114 .ops = &kvaser_usb_leaf_dev_ops, 115 }; 116 117 static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err_listen = { 118 .quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | 119 KVASER_USB_QUIRK_HAS_SILENT_MODE | 120 KVASER_USB_QUIRK_IGNORE_CLK_FREQ, 121 .family = KVASER_LEAF, 122 .ops = &kvaser_usb_leaf_dev_ops, 123 }; 124 125 static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leafimx = { 126 .quirks = 0, 127 .ops = &kvaser_usb_leaf_dev_ops, 128 }; 129 130 static const struct usb_device_id kvaser_usb_table[] = { 131 /* Leaf M32C USB product IDs */ 132 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID), 133 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, 134 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID), 135 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, 136 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID), 137 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 138 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID), 139 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 140 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID), 141 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 142 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID), 143 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 144 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID), 145 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 146 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID), 147 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 148 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID), 149 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 150 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID), 151 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 152 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID), 153 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 154 { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID), 155 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 156 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID), 157 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, 158 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID), 159 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 160 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID), 161 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 162 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID), 163 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 164 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID), 165 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 166 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID), 167 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 168 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID), 169 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 170 { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID), 171 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 172 173 /* Leaf i.MX28 USB product IDs */ 174 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID), 175 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 176 { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID), 177 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 178 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID), 179 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 180 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID), 181 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 182 { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID), 183 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 184 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_R_V2_PRODUCT_ID), 185 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 186 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_R_V2_PRODUCT_ID), 187 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 188 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID), 189 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 190 191 /* USBCANII USB product IDs */ 192 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID), 193 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 194 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_REVB_PRODUCT_ID), 195 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 196 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMORATOR_PRODUCT_ID), 197 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 198 { USB_DEVICE(KVASER_VENDOR_ID, USB_VCI2_PRODUCT_ID), 199 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 200 201 /* Minihydra USB product IDs */ 202 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_V2_PRODUCT_ID), 203 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 204 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_5HS_PRODUCT_ID), 205 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 206 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_5HS_PRODUCT_ID), 207 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 208 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_4HS_PRODUCT_ID), 209 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 210 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_HS_V2_PRODUCT_ID), 211 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 212 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_2HS_V2_PRODUCT_ID), 213 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 214 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_2HS_PRODUCT_ID), 215 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 216 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_2HS_V2_PRODUCT_ID), 217 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 218 { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_2CANLIN_PRODUCT_ID), 219 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 220 { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID), 221 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 222 { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID), 223 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 224 { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_2CANLIN_PRODUCT_ID), 225 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 226 { USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID), 227 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 228 { USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID), 229 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 230 { USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID), 231 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 232 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID), 233 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 234 { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_CANLIN_PRODUCT_ID), 235 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 236 { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_CANLIN_PRODUCT_ID), 237 .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 238 { } 239 }; 240 MODULE_DEVICE_TABLE(usb, kvaser_usb_table); 241 242 int kvaser_usb_send_cmd(const struct kvaser_usb *dev, void *cmd, int len) 243 { 244 return usb_bulk_msg(dev->udev, 245 usb_sndbulkpipe(dev->udev, 246 dev->bulk_out->bEndpointAddress), 247 cmd, len, NULL, KVASER_USB_TIMEOUT); 248 } 249 250 int kvaser_usb_recv_cmd(const struct kvaser_usb *dev, void *cmd, int len, 251 int *actual_len) 252 { 253 return usb_bulk_msg(dev->udev, 254 usb_rcvbulkpipe(dev->udev, 255 dev->bulk_in->bEndpointAddress), 256 cmd, len, actual_len, KVASER_USB_TIMEOUT); 257 } 258 259 static void kvaser_usb_send_cmd_callback(struct urb *urb) 260 { 261 struct net_device *netdev = urb->context; 262 263 kfree(urb->transfer_buffer); 264 265 if (urb->status) 266 netdev_warn(netdev, "urb status received: %d\n", urb->status); 267 } 268 269 int kvaser_usb_send_cmd_async(struct kvaser_usb_net_priv *priv, void *cmd, 270 int len) 271 { 272 struct kvaser_usb *dev = priv->dev; 273 struct net_device *netdev = priv->netdev; 274 struct urb *urb; 275 int err; 276 277 urb = usb_alloc_urb(0, GFP_ATOMIC); 278 if (!urb) 279 return -ENOMEM; 280 281 usb_fill_bulk_urb(urb, dev->udev, 282 usb_sndbulkpipe(dev->udev, 283 dev->bulk_out->bEndpointAddress), 284 cmd, len, kvaser_usb_send_cmd_callback, netdev); 285 usb_anchor_urb(urb, &priv->tx_submitted); 286 287 err = usb_submit_urb(urb, GFP_ATOMIC); 288 if (err) { 289 netdev_err(netdev, "Error transmitting URB\n"); 290 usb_unanchor_urb(urb); 291 } 292 usb_free_urb(urb); 293 294 return 0; 295 } 296 297 int kvaser_usb_can_rx_over_error(struct net_device *netdev) 298 { 299 struct net_device_stats *stats = &netdev->stats; 300 struct can_frame *cf; 301 struct sk_buff *skb; 302 303 stats->rx_over_errors++; 304 stats->rx_errors++; 305 306 skb = alloc_can_err_skb(netdev, &cf); 307 if (!skb) { 308 stats->rx_dropped++; 309 netdev_warn(netdev, "No memory left for err_skb\n"); 310 return -ENOMEM; 311 } 312 313 cf->can_id |= CAN_ERR_CRTL; 314 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 315 316 netif_rx(skb); 317 318 return 0; 319 } 320 321 static void kvaser_usb_read_bulk_callback(struct urb *urb) 322 { 323 struct kvaser_usb *dev = urb->context; 324 const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 325 int err; 326 unsigned int i; 327 328 switch (urb->status) { 329 case 0: 330 break; 331 case -ENOENT: 332 case -EPIPE: 333 case -EPROTO: 334 case -ESHUTDOWN: 335 return; 336 default: 337 dev_info(&dev->intf->dev, "Rx URB aborted (%d)\n", urb->status); 338 goto resubmit_urb; 339 } 340 341 ops->dev_read_bulk_callback(dev, urb->transfer_buffer, 342 urb->actual_length); 343 344 resubmit_urb: 345 usb_fill_bulk_urb(urb, dev->udev, 346 usb_rcvbulkpipe(dev->udev, 347 dev->bulk_in->bEndpointAddress), 348 urb->transfer_buffer, KVASER_USB_RX_BUFFER_SIZE, 349 kvaser_usb_read_bulk_callback, dev); 350 351 err = usb_submit_urb(urb, GFP_ATOMIC); 352 if (err == -ENODEV) { 353 for (i = 0; i < dev->nchannels; i++) { 354 if (!dev->nets[i]) 355 continue; 356 357 netif_device_detach(dev->nets[i]->netdev); 358 } 359 } else if (err) { 360 dev_err(&dev->intf->dev, 361 "Failed resubmitting read bulk urb: %d\n", err); 362 } 363 } 364 365 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev) 366 { 367 int i, err = 0; 368 369 if (dev->rxinitdone) 370 return 0; 371 372 for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++) { 373 struct urb *urb = NULL; 374 u8 *buf = NULL; 375 dma_addr_t buf_dma; 376 377 urb = usb_alloc_urb(0, GFP_KERNEL); 378 if (!urb) { 379 err = -ENOMEM; 380 break; 381 } 382 383 buf = usb_alloc_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE, 384 GFP_KERNEL, &buf_dma); 385 if (!buf) { 386 dev_warn(&dev->intf->dev, 387 "No memory left for USB buffer\n"); 388 usb_free_urb(urb); 389 err = -ENOMEM; 390 break; 391 } 392 393 usb_fill_bulk_urb(urb, dev->udev, 394 usb_rcvbulkpipe 395 (dev->udev, 396 dev->bulk_in->bEndpointAddress), 397 buf, KVASER_USB_RX_BUFFER_SIZE, 398 kvaser_usb_read_bulk_callback, dev); 399 urb->transfer_dma = buf_dma; 400 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 401 usb_anchor_urb(urb, &dev->rx_submitted); 402 403 err = usb_submit_urb(urb, GFP_KERNEL); 404 if (err) { 405 usb_unanchor_urb(urb); 406 usb_free_coherent(dev->udev, 407 KVASER_USB_RX_BUFFER_SIZE, buf, 408 buf_dma); 409 usb_free_urb(urb); 410 break; 411 } 412 413 dev->rxbuf[i] = buf; 414 dev->rxbuf_dma[i] = buf_dma; 415 416 usb_free_urb(urb); 417 } 418 419 if (i == 0) { 420 dev_warn(&dev->intf->dev, "Cannot setup read URBs, error %d\n", 421 err); 422 return err; 423 } else if (i < KVASER_USB_MAX_RX_URBS) { 424 dev_warn(&dev->intf->dev, "RX performances may be slow\n"); 425 } 426 427 dev->rxinitdone = true; 428 429 return 0; 430 } 431 432 static int kvaser_usb_open(struct net_device *netdev) 433 { 434 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 435 struct kvaser_usb *dev = priv->dev; 436 const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 437 int err; 438 439 err = open_candev(netdev); 440 if (err) 441 return err; 442 443 err = kvaser_usb_setup_rx_urbs(dev); 444 if (err) 445 goto error; 446 447 err = ops->dev_set_opt_mode(priv); 448 if (err) 449 goto error; 450 451 err = ops->dev_start_chip(priv); 452 if (err) { 453 netdev_warn(netdev, "Cannot start device, error %d\n", err); 454 goto error; 455 } 456 457 priv->can.state = CAN_STATE_ERROR_ACTIVE; 458 459 return 0; 460 461 error: 462 close_candev(netdev); 463 return err; 464 } 465 466 static void kvaser_usb_reset_tx_urb_contexts(struct kvaser_usb_net_priv *priv) 467 { 468 int i, max_tx_urbs; 469 470 max_tx_urbs = priv->dev->max_tx_urbs; 471 472 priv->active_tx_contexts = 0; 473 for (i = 0; i < max_tx_urbs; i++) 474 priv->tx_contexts[i].echo_index = max_tx_urbs; 475 } 476 477 /* This method might sleep. Do not call it in the atomic context 478 * of URB completions. 479 */ 480 void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv) 481 { 482 usb_kill_anchored_urbs(&priv->tx_submitted); 483 kvaser_usb_reset_tx_urb_contexts(priv); 484 } 485 486 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev) 487 { 488 int i; 489 490 usb_kill_anchored_urbs(&dev->rx_submitted); 491 492 for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++) 493 usb_free_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE, 494 dev->rxbuf[i], dev->rxbuf_dma[i]); 495 496 for (i = 0; i < dev->nchannels; i++) { 497 struct kvaser_usb_net_priv *priv = dev->nets[i]; 498 499 if (priv) 500 kvaser_usb_unlink_tx_urbs(priv); 501 } 502 } 503 504 static int kvaser_usb_close(struct net_device *netdev) 505 { 506 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 507 struct kvaser_usb *dev = priv->dev; 508 const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 509 int err; 510 511 netif_stop_queue(netdev); 512 513 err = ops->dev_flush_queue(priv); 514 if (err) 515 netdev_warn(netdev, "Cannot flush queue, error %d\n", err); 516 517 if (ops->dev_reset_chip) { 518 err = ops->dev_reset_chip(dev, priv->channel); 519 if (err) 520 netdev_warn(netdev, "Cannot reset card, error %d\n", 521 err); 522 } 523 524 err = ops->dev_stop_chip(priv); 525 if (err) 526 netdev_warn(netdev, "Cannot stop device, error %d\n", err); 527 528 /* reset tx contexts */ 529 kvaser_usb_unlink_tx_urbs(priv); 530 531 priv->can.state = CAN_STATE_STOPPED; 532 close_candev(priv->netdev); 533 534 return 0; 535 } 536 537 static void kvaser_usb_write_bulk_callback(struct urb *urb) 538 { 539 struct kvaser_usb_tx_urb_context *context = urb->context; 540 struct kvaser_usb_net_priv *priv; 541 struct net_device *netdev; 542 543 if (WARN_ON(!context)) 544 return; 545 546 priv = context->priv; 547 netdev = priv->netdev; 548 549 kfree(urb->transfer_buffer); 550 551 if (!netif_device_present(netdev)) 552 return; 553 554 if (urb->status) 555 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 556 } 557 558 static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb, 559 struct net_device *netdev) 560 { 561 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 562 struct kvaser_usb *dev = priv->dev; 563 const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 564 struct net_device_stats *stats = &netdev->stats; 565 struct kvaser_usb_tx_urb_context *context = NULL; 566 struct urb *urb; 567 void *buf; 568 int cmd_len = 0; 569 int err, ret = NETDEV_TX_OK; 570 unsigned int i; 571 unsigned long flags; 572 573 if (can_dev_dropped_skb(netdev, skb)) 574 return NETDEV_TX_OK; 575 576 urb = usb_alloc_urb(0, GFP_ATOMIC); 577 if (!urb) { 578 stats->tx_dropped++; 579 dev_kfree_skb(skb); 580 return NETDEV_TX_OK; 581 } 582 583 spin_lock_irqsave(&priv->tx_contexts_lock, flags); 584 for (i = 0; i < dev->max_tx_urbs; i++) { 585 if (priv->tx_contexts[i].echo_index == dev->max_tx_urbs) { 586 context = &priv->tx_contexts[i]; 587 588 context->echo_index = i; 589 ++priv->active_tx_contexts; 590 if (priv->active_tx_contexts >= (int)dev->max_tx_urbs) 591 netif_stop_queue(netdev); 592 593 break; 594 } 595 } 596 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 597 598 /* This should never happen; it implies a flow control bug */ 599 if (!context) { 600 netdev_warn(netdev, "cannot find free context\n"); 601 602 ret = NETDEV_TX_BUSY; 603 goto freeurb; 604 } 605 606 buf = ops->dev_frame_to_cmd(priv, skb, &cmd_len, context->echo_index); 607 if (!buf) { 608 stats->tx_dropped++; 609 dev_kfree_skb(skb); 610 spin_lock_irqsave(&priv->tx_contexts_lock, flags); 611 612 context->echo_index = dev->max_tx_urbs; 613 --priv->active_tx_contexts; 614 netif_wake_queue(netdev); 615 616 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 617 goto freeurb; 618 } 619 620 context->priv = priv; 621 622 can_put_echo_skb(skb, netdev, context->echo_index, 0); 623 624 usb_fill_bulk_urb(urb, dev->udev, 625 usb_sndbulkpipe(dev->udev, 626 dev->bulk_out->bEndpointAddress), 627 buf, cmd_len, kvaser_usb_write_bulk_callback, 628 context); 629 usb_anchor_urb(urb, &priv->tx_submitted); 630 631 err = usb_submit_urb(urb, GFP_ATOMIC); 632 if (unlikely(err)) { 633 spin_lock_irqsave(&priv->tx_contexts_lock, flags); 634 635 can_free_echo_skb(netdev, context->echo_index, NULL); 636 context->echo_index = dev->max_tx_urbs; 637 --priv->active_tx_contexts; 638 netif_wake_queue(netdev); 639 640 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 641 642 usb_unanchor_urb(urb); 643 kfree(buf); 644 645 stats->tx_dropped++; 646 647 if (err == -ENODEV) 648 netif_device_detach(netdev); 649 else 650 netdev_warn(netdev, "Failed tx_urb %d\n", err); 651 652 goto freeurb; 653 } 654 655 ret = NETDEV_TX_OK; 656 657 freeurb: 658 usb_free_urb(urb); 659 return ret; 660 } 661 662 static const struct net_device_ops kvaser_usb_netdev_ops = { 663 .ndo_open = kvaser_usb_open, 664 .ndo_stop = kvaser_usb_close, 665 .ndo_start_xmit = kvaser_usb_start_xmit, 666 .ndo_change_mtu = can_change_mtu, 667 }; 668 669 static const struct net_device_ops kvaser_usb_netdev_ops_hwts = { 670 .ndo_open = kvaser_usb_open, 671 .ndo_stop = kvaser_usb_close, 672 .ndo_eth_ioctl = can_eth_ioctl_hwts, 673 .ndo_start_xmit = kvaser_usb_start_xmit, 674 .ndo_change_mtu = can_change_mtu, 675 }; 676 677 static const struct ethtool_ops kvaser_usb_ethtool_ops = { 678 .get_ts_info = ethtool_op_get_ts_info, 679 }; 680 681 static const struct ethtool_ops kvaser_usb_ethtool_ops_hwts = { 682 .get_ts_info = can_ethtool_op_get_ts_info_hwts, 683 }; 684 685 static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev) 686 { 687 int i; 688 689 for (i = 0; i < dev->nchannels; i++) { 690 if (!dev->nets[i]) 691 continue; 692 693 unregister_candev(dev->nets[i]->netdev); 694 } 695 696 kvaser_usb_unlink_all_urbs(dev); 697 698 for (i = 0; i < dev->nchannels; i++) { 699 if (!dev->nets[i]) 700 continue; 701 702 free_candev(dev->nets[i]->netdev); 703 } 704 } 705 706 static int kvaser_usb_init_one(struct kvaser_usb *dev, int channel) 707 { 708 struct net_device *netdev; 709 struct kvaser_usb_net_priv *priv; 710 const struct kvaser_usb_driver_info *driver_info = dev->driver_info; 711 const struct kvaser_usb_dev_ops *ops = driver_info->ops; 712 int err; 713 714 if (ops->dev_reset_chip) { 715 err = ops->dev_reset_chip(dev, channel); 716 if (err) 717 return err; 718 } 719 720 netdev = alloc_candev(struct_size(priv, tx_contexts, dev->max_tx_urbs), 721 dev->max_tx_urbs); 722 if (!netdev) { 723 dev_err(&dev->intf->dev, "Cannot alloc candev\n"); 724 return -ENOMEM; 725 } 726 727 priv = netdev_priv(netdev); 728 729 init_usb_anchor(&priv->tx_submitted); 730 init_completion(&priv->start_comp); 731 init_completion(&priv->stop_comp); 732 init_completion(&priv->flush_comp); 733 priv->can.ctrlmode_supported = 0; 734 735 priv->dev = dev; 736 priv->netdev = netdev; 737 priv->channel = channel; 738 739 spin_lock_init(&priv->tx_contexts_lock); 740 kvaser_usb_reset_tx_urb_contexts(priv); 741 742 priv->can.state = CAN_STATE_STOPPED; 743 priv->can.clock.freq = dev->cfg->clock.freq; 744 priv->can.bittiming_const = dev->cfg->bittiming_const; 745 priv->can.do_set_bittiming = ops->dev_set_bittiming; 746 priv->can.do_set_mode = ops->dev_set_mode; 747 if ((driver_info->quirks & KVASER_USB_QUIRK_HAS_TXRX_ERRORS) || 748 (priv->dev->card_data.capabilities & KVASER_USB_CAP_BERR_CAP)) 749 priv->can.do_get_berr_counter = ops->dev_get_berr_counter; 750 if (driver_info->quirks & KVASER_USB_QUIRK_HAS_SILENT_MODE) 751 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 752 753 priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported; 754 755 if (priv->can.ctrlmode_supported & CAN_CTRLMODE_FD) { 756 priv->can.data_bittiming_const = dev->cfg->data_bittiming_const; 757 priv->can.do_set_data_bittiming = ops->dev_set_data_bittiming; 758 } 759 760 netdev->flags |= IFF_ECHO; 761 762 netdev->netdev_ops = &kvaser_usb_netdev_ops; 763 if (driver_info->quirks & KVASER_USB_QUIRK_HAS_HARDWARE_TIMESTAMP) { 764 netdev->netdev_ops = &kvaser_usb_netdev_ops_hwts; 765 netdev->ethtool_ops = &kvaser_usb_ethtool_ops_hwts; 766 } else { 767 netdev->netdev_ops = &kvaser_usb_netdev_ops; 768 netdev->ethtool_ops = &kvaser_usb_ethtool_ops; 769 } 770 SET_NETDEV_DEV(netdev, &dev->intf->dev); 771 netdev->dev_id = channel; 772 773 dev->nets[channel] = priv; 774 775 err = register_candev(netdev); 776 if (err) { 777 dev_err(&dev->intf->dev, "Failed to register CAN device\n"); 778 free_candev(netdev); 779 dev->nets[channel] = NULL; 780 return err; 781 } 782 783 netdev_dbg(netdev, "device registered\n"); 784 785 return 0; 786 } 787 788 static int kvaser_usb_probe(struct usb_interface *intf, 789 const struct usb_device_id *id) 790 { 791 struct kvaser_usb *dev; 792 int err; 793 int i; 794 const struct kvaser_usb_driver_info *driver_info; 795 const struct kvaser_usb_dev_ops *ops; 796 797 driver_info = (const struct kvaser_usb_driver_info *)id->driver_info; 798 if (!driver_info) 799 return -ENODEV; 800 801 dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL); 802 if (!dev) 803 return -ENOMEM; 804 805 dev->intf = intf; 806 dev->driver_info = driver_info; 807 ops = driver_info->ops; 808 809 err = ops->dev_setup_endpoints(dev); 810 if (err) { 811 dev_err(&intf->dev, "Cannot get usb endpoint(s)"); 812 return err; 813 } 814 815 dev->udev = interface_to_usbdev(intf); 816 817 init_usb_anchor(&dev->rx_submitted); 818 819 usb_set_intfdata(intf, dev); 820 821 dev->card_data.ctrlmode_supported = 0; 822 dev->card_data.capabilities = 0; 823 err = ops->dev_init_card(dev); 824 if (err) { 825 dev_err(&intf->dev, 826 "Failed to initialize card, error %d\n", err); 827 return err; 828 } 829 830 err = ops->dev_get_software_info(dev); 831 if (err) { 832 dev_err(&intf->dev, 833 "Cannot get software info, error %d\n", err); 834 return err; 835 } 836 837 if (ops->dev_get_software_details) { 838 err = ops->dev_get_software_details(dev); 839 if (err) { 840 dev_err(&intf->dev, 841 "Cannot get software details, error %d\n", err); 842 return err; 843 } 844 } 845 846 if (WARN_ON(!dev->cfg)) 847 return -ENODEV; 848 849 dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n", 850 ((dev->fw_version >> 24) & 0xff), 851 ((dev->fw_version >> 16) & 0xff), 852 (dev->fw_version & 0xffff)); 853 854 dev_dbg(&intf->dev, "Max outstanding tx = %d URBs\n", dev->max_tx_urbs); 855 856 err = ops->dev_get_card_info(dev); 857 if (err) { 858 dev_err(&intf->dev, "Cannot get card info, error %d\n", err); 859 return err; 860 } 861 862 if (ops->dev_get_capabilities) { 863 err = ops->dev_get_capabilities(dev); 864 if (err) { 865 dev_err(&intf->dev, 866 "Cannot get capabilities, error %d\n", err); 867 kvaser_usb_remove_interfaces(dev); 868 return err; 869 } 870 } 871 872 for (i = 0; i < dev->nchannels; i++) { 873 err = kvaser_usb_init_one(dev, i); 874 if (err) { 875 kvaser_usb_remove_interfaces(dev); 876 return err; 877 } 878 } 879 880 return 0; 881 } 882 883 static void kvaser_usb_disconnect(struct usb_interface *intf) 884 { 885 struct kvaser_usb *dev = usb_get_intfdata(intf); 886 887 usb_set_intfdata(intf, NULL); 888 889 if (!dev) 890 return; 891 892 kvaser_usb_remove_interfaces(dev); 893 } 894 895 static struct usb_driver kvaser_usb_driver = { 896 .name = KBUILD_MODNAME, 897 .probe = kvaser_usb_probe, 898 .disconnect = kvaser_usb_disconnect, 899 .id_table = kvaser_usb_table, 900 }; 901 902 module_usb_driver(kvaser_usb_driver); 903 904 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>"); 905 MODULE_AUTHOR("Kvaser AB <support@kvaser.com>"); 906 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices"); 907 MODULE_LICENSE("GPL v2"); 908