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/gfp.h> 17 #include <linux/if.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> 24 25 #include <linux/can.h> 26 #include <linux/can/dev.h> 27 #include <linux/can/error.h> 28 #include <linux/can/netlink.h> 29 30 #include "kvaser_usb.h" 31 32 /* Kvaser USB vendor id. */ 33 #define KVASER_VENDOR_ID 0x0bfd 34 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 66 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 72 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 \ 90 USB_U100S_PRODUCT_ID 91 92 static inline bool kvaser_is_leaf(const struct usb_device_id *id) 93 { 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); 98 } 99 100 static inline bool kvaser_is_usbcan(const struct usb_device_id *id) 101 { 102 return id->idProduct >= USB_USBCAN_REVB_PRODUCT_ID && 103 id->idProduct <= USB_MEMORATOR_PRODUCT_ID; 104 } 105 106 static inline bool kvaser_is_hydra(const struct usb_device_id *id) 107 { 108 return id->idProduct >= USB_BLACKBIRD_V2_PRODUCT_ID && 109 id->idProduct <= USB_HYDRA_PRODUCT_ID_END; 110 } 111 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) }, 169 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 }, 179 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) }, 196 { } 197 }; 198 MODULE_DEVICE_TABLE(usb, kvaser_usb_table); 199 200 int kvaser_usb_send_cmd(const struct kvaser_usb *dev, void *cmd, int len) 201 { 202 int actual_len; /* Not used */ 203 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); 208 } 209 210 int kvaser_usb_recv_cmd(const struct kvaser_usb *dev, void *cmd, int len, 211 int *actual_len) 212 { 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); 217 } 218 219 static void kvaser_usb_send_cmd_callback(struct urb *urb) 220 { 221 struct net_device *netdev = urb->context; 222 223 kfree(urb->transfer_buffer); 224 225 if (urb->status) 226 netdev_warn(netdev, "urb status received: %d\n", urb->status); 227 } 228 229 int kvaser_usb_send_cmd_async(struct kvaser_usb_net_priv *priv, void *cmd, 230 int len) 231 { 232 struct kvaser_usb *dev = priv->dev; 233 struct net_device *netdev = priv->netdev; 234 struct urb *urb; 235 int err; 236 237 urb = usb_alloc_urb(0, GFP_ATOMIC); 238 if (!urb) 239 return -ENOMEM; 240 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); 246 247 err = usb_submit_urb(urb, GFP_ATOMIC); 248 if (err) { 249 netdev_err(netdev, "Error transmitting URB\n"); 250 usb_unanchor_urb(urb); 251 } 252 usb_free_urb(urb); 253 254 return 0; 255 } 256 257 int kvaser_usb_can_rx_over_error(struct net_device *netdev) 258 { 259 struct net_device_stats *stats = &netdev->stats; 260 struct can_frame *cf; 261 struct sk_buff *skb; 262 263 stats->rx_over_errors++; 264 stats->rx_errors++; 265 266 skb = alloc_can_err_skb(netdev, &cf); 267 if (!skb) { 268 stats->rx_dropped++; 269 netdev_warn(netdev, "No memory left for err_skb\n"); 270 return -ENOMEM; 271 } 272 273 cf->can_id |= CAN_ERR_CRTL; 274 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 275 276 stats->rx_packets++; 277 stats->rx_bytes += cf->len; 278 netif_rx(skb); 279 280 return 0; 281 } 282 283 static void kvaser_usb_read_bulk_callback(struct urb *urb) 284 { 285 struct kvaser_usb *dev = urb->context; 286 int err; 287 unsigned int i; 288 289 switch (urb->status) { 290 case 0: 291 break; 292 case -ENOENT: 293 case -EPIPE: 294 case -EPROTO: 295 case -ESHUTDOWN: 296 return; 297 default: 298 dev_info(&dev->intf->dev, "Rx URB aborted (%d)\n", urb->status); 299 goto resubmit_urb; 300 } 301 302 dev->ops->dev_read_bulk_callback(dev, urb->transfer_buffer, 303 urb->actual_length); 304 305 resubmit_urb: 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); 311 312 err = usb_submit_urb(urb, GFP_ATOMIC); 313 if (err == -ENODEV) { 314 for (i = 0; i < dev->nchannels; i++) { 315 if (!dev->nets[i]) 316 continue; 317 318 netif_device_detach(dev->nets[i]->netdev); 319 } 320 } else if (err) { 321 dev_err(&dev->intf->dev, 322 "Failed resubmitting read bulk urb: %d\n", err); 323 } 324 } 325 326 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev) 327 { 328 int i, err = 0; 329 330 if (dev->rxinitdone) 331 return 0; 332 333 for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++) { 334 struct urb *urb = NULL; 335 u8 *buf = NULL; 336 dma_addr_t buf_dma; 337 338 urb = usb_alloc_urb(0, GFP_KERNEL); 339 if (!urb) { 340 err = -ENOMEM; 341 break; 342 } 343 344 buf = usb_alloc_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE, 345 GFP_KERNEL, &buf_dma); 346 if (!buf) { 347 dev_warn(&dev->intf->dev, 348 "No memory left for USB buffer\n"); 349 usb_free_urb(urb); 350 err = -ENOMEM; 351 break; 352 } 353 354 usb_fill_bulk_urb(urb, dev->udev, 355 usb_rcvbulkpipe 356 (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); 363 364 err = usb_submit_urb(urb, GFP_KERNEL); 365 if (err) { 366 usb_unanchor_urb(urb); 367 usb_free_coherent(dev->udev, 368 KVASER_USB_RX_BUFFER_SIZE, buf, 369 buf_dma); 370 usb_free_urb(urb); 371 break; 372 } 373 374 dev->rxbuf[i] = buf; 375 dev->rxbuf_dma[i] = buf_dma; 376 377 usb_free_urb(urb); 378 } 379 380 if (i == 0) { 381 dev_warn(&dev->intf->dev, "Cannot setup read URBs, error %d\n", 382 err); 383 return err; 384 } else if (i < KVASER_USB_MAX_RX_URBS) { 385 dev_warn(&dev->intf->dev, "RX performances may be slow\n"); 386 } 387 388 dev->rxinitdone = true; 389 390 return 0; 391 } 392 393 static int kvaser_usb_open(struct net_device *netdev) 394 { 395 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 396 struct kvaser_usb *dev = priv->dev; 397 int err; 398 399 err = open_candev(netdev); 400 if (err) 401 return err; 402 403 err = kvaser_usb_setup_rx_urbs(dev); 404 if (err) 405 goto error; 406 407 err = dev->ops->dev_set_opt_mode(priv); 408 if (err) 409 goto error; 410 411 err = dev->ops->dev_start_chip(priv); 412 if (err) { 413 netdev_warn(netdev, "Cannot start device, error %d\n", err); 414 goto error; 415 } 416 417 priv->can.state = CAN_STATE_ERROR_ACTIVE; 418 419 return 0; 420 421 error: 422 close_candev(netdev); 423 return err; 424 } 425 426 static void kvaser_usb_reset_tx_urb_contexts(struct kvaser_usb_net_priv *priv) 427 { 428 int i, max_tx_urbs; 429 430 max_tx_urbs = priv->dev->max_tx_urbs; 431 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; 435 } 436 437 /* This method might sleep. Do not call it in the atomic context 438 * of URB completions. 439 */ 440 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv) 441 { 442 usb_kill_anchored_urbs(&priv->tx_submitted); 443 kvaser_usb_reset_tx_urb_contexts(priv); 444 } 445 446 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev) 447 { 448 int i; 449 450 usb_kill_anchored_urbs(&dev->rx_submitted); 451 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]); 455 456 for (i = 0; i < dev->nchannels; i++) { 457 struct kvaser_usb_net_priv *priv = dev->nets[i]; 458 459 if (priv) 460 kvaser_usb_unlink_tx_urbs(priv); 461 } 462 } 463 464 static int kvaser_usb_close(struct net_device *netdev) 465 { 466 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 467 struct kvaser_usb *dev = priv->dev; 468 int err; 469 470 netif_stop_queue(netdev); 471 472 err = dev->ops->dev_flush_queue(priv); 473 if (err) 474 netdev_warn(netdev, "Cannot flush queue, error %d\n", err); 475 476 if (dev->ops->dev_reset_chip) { 477 err = dev->ops->dev_reset_chip(dev, priv->channel); 478 if (err) 479 netdev_warn(netdev, "Cannot reset card, error %d\n", 480 err); 481 } 482 483 err = dev->ops->dev_stop_chip(priv); 484 if (err) 485 netdev_warn(netdev, "Cannot stop device, error %d\n", err); 486 487 /* reset tx contexts */ 488 kvaser_usb_unlink_tx_urbs(priv); 489 490 priv->can.state = CAN_STATE_STOPPED; 491 close_candev(priv->netdev); 492 493 return 0; 494 } 495 496 static void kvaser_usb_write_bulk_callback(struct urb *urb) 497 { 498 struct kvaser_usb_tx_urb_context *context = urb->context; 499 struct kvaser_usb_net_priv *priv; 500 struct net_device *netdev; 501 502 if (WARN_ON(!context)) 503 return; 504 505 priv = context->priv; 506 netdev = priv->netdev; 507 508 kfree(urb->transfer_buffer); 509 510 if (!netif_device_present(netdev)) 511 return; 512 513 if (urb->status) 514 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 515 } 516 517 static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb, 518 struct net_device *netdev) 519 { 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; 524 struct urb *urb; 525 void *buf; 526 int cmd_len = 0; 527 int err, ret = NETDEV_TX_OK; 528 unsigned int i; 529 unsigned long flags; 530 531 if (can_dropped_invalid_skb(netdev, skb)) 532 return NETDEV_TX_OK; 533 534 urb = usb_alloc_urb(0, GFP_ATOMIC); 535 if (!urb) { 536 stats->tx_dropped++; 537 dev_kfree_skb(skb); 538 return NETDEV_TX_OK; 539 } 540 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]; 545 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); 550 551 break; 552 } 553 } 554 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 555 556 /* This should never happen; it implies a flow control bug */ 557 if (!context) { 558 netdev_warn(netdev, "cannot find free context\n"); 559 560 ret = NETDEV_TX_BUSY; 561 goto freeurb; 562 } 563 564 buf = dev->ops->dev_frame_to_cmd(priv, skb, &context->dlc, &cmd_len, 565 context->echo_index); 566 if (!buf) { 567 stats->tx_dropped++; 568 dev_kfree_skb(skb); 569 spin_lock_irqsave(&priv->tx_contexts_lock, flags); 570 571 context->echo_index = dev->max_tx_urbs; 572 --priv->active_tx_contexts; 573 netif_wake_queue(netdev); 574 575 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 576 goto freeurb; 577 } 578 579 context->priv = priv; 580 581 can_put_echo_skb(skb, netdev, context->echo_index, 0); 582 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, 587 context); 588 usb_anchor_urb(urb, &priv->tx_submitted); 589 590 err = usb_submit_urb(urb, GFP_ATOMIC); 591 if (unlikely(err)) { 592 spin_lock_irqsave(&priv->tx_contexts_lock, flags); 593 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); 598 599 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 600 601 usb_unanchor_urb(urb); 602 kfree(buf); 603 604 stats->tx_dropped++; 605 606 if (err == -ENODEV) 607 netif_device_detach(netdev); 608 else 609 netdev_warn(netdev, "Failed tx_urb %d\n", err); 610 611 goto freeurb; 612 } 613 614 ret = NETDEV_TX_OK; 615 616 freeurb: 617 usb_free_urb(urb); 618 return ret; 619 } 620 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, 626 }; 627 628 static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev) 629 { 630 int i; 631 632 for (i = 0; i < dev->nchannels; i++) { 633 if (!dev->nets[i]) 634 continue; 635 636 unregister_candev(dev->nets[i]->netdev); 637 } 638 639 kvaser_usb_unlink_all_urbs(dev); 640 641 for (i = 0; i < dev->nchannels; i++) { 642 if (!dev->nets[i]) 643 continue; 644 645 free_candev(dev->nets[i]->netdev); 646 } 647 } 648 649 static int kvaser_usb_init_one(struct kvaser_usb *dev, 650 const struct usb_device_id *id, int channel) 651 { 652 struct net_device *netdev; 653 struct kvaser_usb_net_priv *priv; 654 int err; 655 656 if (dev->ops->dev_reset_chip) { 657 err = dev->ops->dev_reset_chip(dev, channel); 658 if (err) 659 return err; 660 } 661 662 netdev = alloc_candev(struct_size(priv, tx_contexts, dev->max_tx_urbs), 663 dev->max_tx_urbs); 664 if (!netdev) { 665 dev_err(&dev->intf->dev, "Cannot alloc candev\n"); 666 return -ENOMEM; 667 } 668 669 priv = netdev_priv(netdev); 670 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; 675 676 priv->dev = dev; 677 priv->netdev = netdev; 678 priv->channel = channel; 679 680 spin_lock_init(&priv->tx_contexts_lock); 681 kvaser_usb_reset_tx_urb_contexts(priv); 682 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; 693 694 priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported; 695 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; 700 } 701 702 netdev->flags |= IFF_ECHO; 703 704 netdev->netdev_ops = &kvaser_usb_netdev_ops; 705 706 SET_NETDEV_DEV(netdev, &dev->intf->dev); 707 netdev->dev_id = channel; 708 709 dev->nets[channel] = priv; 710 711 err = register_candev(netdev); 712 if (err) { 713 dev_err(&dev->intf->dev, "Failed to register CAN device\n"); 714 free_candev(netdev); 715 dev->nets[channel] = NULL; 716 return err; 717 } 718 719 netdev_dbg(netdev, "device registered\n"); 720 721 return 0; 722 } 723 724 static int kvaser_usb_probe(struct usb_interface *intf, 725 const struct usb_device_id *id) 726 { 727 struct kvaser_usb *dev; 728 int err; 729 int i; 730 731 dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL); 732 if (!dev) 733 return -ENOMEM; 734 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; 743 } else { 744 dev_err(&intf->dev, 745 "Product ID (%d) is not a supported Kvaser USB device\n", 746 id->idProduct); 747 return -ENODEV; 748 } 749 750 dev->intf = intf; 751 752 err = dev->ops->dev_setup_endpoints(dev); 753 if (err) { 754 dev_err(&intf->dev, "Cannot get usb endpoint(s)"); 755 return err; 756 } 757 758 dev->udev = interface_to_usbdev(intf); 759 760 init_usb_anchor(&dev->rx_submitted); 761 762 usb_set_intfdata(intf, dev); 763 764 dev->card_data.ctrlmode_supported = 0; 765 dev->card_data.capabilities = 0; 766 err = dev->ops->dev_init_card(dev); 767 if (err) { 768 dev_err(&intf->dev, 769 "Failed to initialize card, error %d\n", err); 770 return err; 771 } 772 773 err = dev->ops->dev_get_software_info(dev); 774 if (err) { 775 dev_err(&intf->dev, 776 "Cannot get software info, error %d\n", err); 777 return err; 778 } 779 780 if (dev->ops->dev_get_software_details) { 781 err = dev->ops->dev_get_software_details(dev); 782 if (err) { 783 dev_err(&intf->dev, 784 "Cannot get software details, error %d\n", err); 785 return err; 786 } 787 } 788 789 if (WARN_ON(!dev->cfg)) 790 return -ENODEV; 791 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)); 796 797 dev_dbg(&intf->dev, "Max outstanding tx = %d URBs\n", dev->max_tx_urbs); 798 799 err = dev->ops->dev_get_card_info(dev); 800 if (err) { 801 dev_err(&intf->dev, "Cannot get card info, error %d\n", err); 802 return err; 803 } 804 805 if (dev->ops->dev_get_capabilities) { 806 err = dev->ops->dev_get_capabilities(dev); 807 if (err) { 808 dev_err(&intf->dev, 809 "Cannot get capabilities, error %d\n", err); 810 kvaser_usb_remove_interfaces(dev); 811 return err; 812 } 813 } 814 815 for (i = 0; i < dev->nchannels; i++) { 816 err = kvaser_usb_init_one(dev, id, i); 817 if (err) { 818 kvaser_usb_remove_interfaces(dev); 819 return err; 820 } 821 } 822 823 return 0; 824 } 825 826 static void kvaser_usb_disconnect(struct usb_interface *intf) 827 { 828 struct kvaser_usb *dev = usb_get_intfdata(intf); 829 830 usb_set_intfdata(intf, NULL); 831 832 if (!dev) 833 return; 834 835 kvaser_usb_remove_interfaces(dev); 836 } 837 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, 843 }; 844 845 module_usb_driver(kvaser_usb_driver); 846 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"); 851