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