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