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