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