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 = ops->dev_set_opt_mode(priv);
 420         if (err)
 421                 goto error;
 422
 423         err = ops->dev_start_chip(priv);
 424         if (err) {
 425                 netdev_warn(netdev, "Cannot start device, error %d\n", err);
 426                 goto error;
 427         }
 428
 429         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 430
 431         return 0;
 432
 433 error:
 434         close_candev(netdev);
 435         return err;
 436 }
 437
 438 static void kvaser_usb_reset_tx_urb_contexts(struct kvaser_usb_net_priv *priv)
 439 {
 440         int i, max_tx_urbs;
 441
 442         max_tx_urbs = priv->dev->max_tx_urbs;
 443
 444         priv->active_tx_contexts = 0;
 445         for (i = 0; i < max_tx_urbs; i++)
 446                 priv->tx_contexts[i].echo_index = max_tx_urbs;
 447 }
 448
 449 /* This method might sleep. Do not call it in the atomic context
 450  * of URB completions.
 451  */
 452 void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv)
 453 {
 454         usb_kill_anchored_urbs(&priv->tx_submitted);
 455         kvaser_usb_reset_tx_urb_contexts(priv);
 456 }
 457
 458 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev)
 459 {
 460         int i;
 461
 462         usb_kill_anchored_urbs(&dev->rx_submitted);
 463
 464         for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++)
 465                 usb_free_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE,
 466                                   dev->rxbuf[i], dev->rxbuf_dma[i]);
 467
 468         for (i = 0; i < dev->nchannels; i++) {
 469                 struct kvaser_usb_net_priv *priv = dev->nets[i];
 470
 471                 if (priv)
 472                         kvaser_usb_unlink_tx_urbs(priv);
 473         }
 474 }
 475
 476 static int kvaser_usb_close(struct net_device *netdev)
 477 {
 478         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
 479         struct kvaser_usb *dev = priv->dev;
 480         const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops;
 481         int err;
 482
 483         netif_stop_queue(netdev);
 484
 485         err = ops->dev_flush_queue(priv);
 486         if (err)
 487                 netdev_warn(netdev, "Cannot flush queue, error %d\n", err);
 488
 489         if (ops->dev_reset_chip) {
 490                 err = ops->dev_reset_chip(dev, priv->channel);
 491                 if (err)
 492                         netdev_warn(netdev, "Cannot reset card, error %d\n",
 493                                     err);
 494         }
 495
 496         err = ops->dev_stop_chip(priv);
 497         if (err)
 498                 netdev_warn(netdev, "Cannot stop device, error %d\n", err);
 499
 500         /* reset tx contexts */
 501         kvaser_usb_unlink_tx_urbs(priv);
 502
 503         priv->can.state = CAN_STATE_STOPPED;
 504         close_candev(priv->netdev);
 505
 506         return 0;
 507 }
 508
 509 static int kvaser_usb_set_bittiming(struct net_device *netdev)
 510 {
 511         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
 512         struct kvaser_usb *dev = priv->dev;
 513         const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops;
 514         struct can_bittiming *bt = &priv->can.bittiming;
 515
 516         struct kvaser_usb_busparams busparams;
 517         int tseg1 = bt->prop_seg + bt->phase_seg1;
 518         int tseg2 = bt->phase_seg2;
 519         int sjw = bt->sjw;
 520         int err = -EOPNOTSUPP;
 521
 522         busparams.bitrate = cpu_to_le32(bt->bitrate);
 523         busparams.sjw = (u8)sjw;
 524         busparams.tseg1 = (u8)tseg1;
 525         busparams.tseg2 = (u8)tseg2;
 526         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 527                 busparams.nsamples = 3;
 528         else
 529                 busparams.nsamples = 1;
 530
 531         err = ops->dev_set_bittiming(netdev, &busparams);
 532         if (err)
 533                 return err;
 534
 535         err = kvaser_usb_setup_rx_urbs(priv->dev);
 536         if (err)
 537                 return err;
 538
 539         err = ops->dev_get_busparams(priv);
 540         if (err) {
 541                 /* Treat EOPNOTSUPP as success */
 542                 if (err == -EOPNOTSUPP)
 543                         err = 0;
 544                 return err;
 545         }
 546
 547         if (memcmp(&busparams, &priv->busparams_nominal,
 548                    sizeof(priv->busparams_nominal)) != 0)
 549                 err = -EINVAL;
 550
 551         return err;
 552 }
 553
 554 static int kvaser_usb_set_data_bittiming(struct net_device *netdev)
 555 {
 556         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
 557         struct kvaser_usb *dev = priv->dev;
 558         const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops;
 559         struct can_bittiming *dbt = &priv->can.data_bittiming;
 560
 561         struct kvaser_usb_busparams busparams;
 562         int tseg1 = dbt->prop_seg + dbt->phase_seg1;
 563         int tseg2 = dbt->phase_seg2;
 564         int sjw = dbt->sjw;
 565         int err;
 566
 567         if (!ops->dev_set_data_bittiming ||
 568             !ops->dev_get_data_busparams)
 569                 return -EOPNOTSUPP;
 570
 571         busparams.bitrate = cpu_to_le32(dbt->bitrate);
 572         busparams.sjw = (u8)sjw;
 573         busparams.tseg1 = (u8)tseg1;
 574         busparams.tseg2 = (u8)tseg2;
 575         busparams.nsamples = 1;
 576
 577         err = ops->dev_set_data_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_data_busparams(priv);
 586         if (err)
 587                 return err;
 588
 589         if (memcmp(&busparams, &priv->busparams_data,
 590                    sizeof(priv->busparams_data)) != 0)
 591                 err = -EINVAL;
 592
 593         return err;
 594 }
 595
 596 static void kvaser_usb_write_bulk_callback(struct urb *urb)
 597 {
 598         struct kvaser_usb_tx_urb_context *context = urb->context;
 599         struct kvaser_usb_net_priv *priv;
 600         struct net_device *netdev;
 601
 602         if (WARN_ON(!context))
 603                 return;
 604
 605         priv = context->priv;
 606         netdev = priv->netdev;
 607
 608         kfree(urb->transfer_buffer);
 609
 610         if (!netif_device_present(netdev))
 611                 return;
 612
 613         if (urb->status)
 614                 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
 615 }
 616
 617 static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb,
 618                                          struct net_device *netdev)
 619 {
 620         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
 621         struct kvaser_usb *dev = priv->dev;
 622         const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops;
 623         struct net_device_stats *stats = &netdev->stats;
 624         struct kvaser_usb_tx_urb_context *context = NULL;
 625         struct urb *urb;
 626         void *buf;
 627         int cmd_len = 0;
 628         int err, ret = NETDEV_TX_OK;
 629         unsigned int i;
 630         unsigned long flags;
 631
 632         if (can_dropped_invalid_skb(netdev, skb))
 633                 return NETDEV_TX_OK;
 634
 635         urb = usb_alloc_urb(0, GFP_ATOMIC);
 636         if (!urb) {
 637                 stats->tx_dropped++;
 638                 dev_kfree_skb(skb);
 639                 return NETDEV_TX_OK;
 640         }
 641
 642         spin_lock_irqsave(&priv->tx_contexts_lock, flags);
 643         for (i = 0; i < dev->max_tx_urbs; i++) {
 644                 if (priv->tx_contexts[i].echo_index == dev->max_tx_urbs) {
 645                         context = &priv->tx_contexts[i];
 646
 647                         context->echo_index = i;
 648                         ++priv->active_tx_contexts;
 649                         if (priv->active_tx_contexts >= (int)dev->max_tx_urbs)
 650                                 netif_stop_queue(netdev);
 651
 652                         break;
 653                 }
 654         }
 655         spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
 656
 657         /* This should never happen; it implies a flow control bug */
 658         if (!context) {
 659                 netdev_warn(netdev, "cannot find free context\n");
 660
 661                 ret = NETDEV_TX_BUSY;
 662                 goto freeurb;
 663         }
 664
 665         buf = ops->dev_frame_to_cmd(priv, skb, &context->dlc, &cmd_len,
 666                                     context->echo_index);
 667         if (!buf) {
 668                 stats->tx_dropped++;
 669                 dev_kfree_skb(skb);
 670                 spin_lock_irqsave(&priv->tx_contexts_lock, flags);
 671
 672                 context->echo_index = dev->max_tx_urbs;
 673                 --priv->active_tx_contexts;
 674                 netif_wake_queue(netdev);
 675
 676                 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
 677                 goto freeurb;
 678         }
 679
 680         context->priv = priv;
 681
 682         can_put_echo_skb(skb, netdev, context->echo_index);
 683
 684         usb_fill_bulk_urb(urb, dev->udev,
 685                           usb_sndbulkpipe(dev->udev,
 686                                           dev->bulk_out->bEndpointAddress),
 687                           buf, cmd_len, kvaser_usb_write_bulk_callback,
 688                           context);
 689         usb_anchor_urb(urb, &priv->tx_submitted);
 690
 691         err = usb_submit_urb(urb, GFP_ATOMIC);
 692         if (unlikely(err)) {
 693                 spin_lock_irqsave(&priv->tx_contexts_lock, flags);
 694
 695                 can_free_echo_skb(netdev, context->echo_index);
 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
 702                 usb_unanchor_urb(urb);
 703                 kfree(buf);
 704
 705                 stats->tx_dropped++;
 706
 707                 if (err == -ENODEV)
 708                         netif_device_detach(netdev);
 709                 else
 710                         netdev_warn(netdev, "Failed tx_urb %d\n", err);
 711
 712                 goto freeurb;
 713         }
 714
 715         ret = NETDEV_TX_OK;
 716
 717 freeurb:
 718         usb_free_urb(urb);
 719         return ret;
 720 }
 721
 722 static const struct net_device_ops kvaser_usb_netdev_ops = {
 723         .ndo_open = kvaser_usb_open,
 724         .ndo_stop = kvaser_usb_close,
 725         .ndo_start_xmit = kvaser_usb_start_xmit,
 726         .ndo_change_mtu = can_change_mtu,
 727 };
 728
 729 static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev)
 730 {
 731         const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops;
 732         int i;
 733
 734         for (i = 0; i < dev->nchannels; i++) {
 735                 if (!dev->nets[i])
 736                         continue;
 737
 738                 unregister_candev(dev->nets[i]->netdev);
 739         }
 740
 741         kvaser_usb_unlink_all_urbs(dev);
 742
 743         for (i = 0; i < dev->nchannels; i++) {
 744                 if (!dev->nets[i])
 745                         continue;
 746
 747                 if (ops->dev_remove_channel)
 748                         ops->dev_remove_channel(dev->nets[i]);
 749
 750                 free_candev(dev->nets[i]->netdev);
 751         }
 752 }
 753
 754 static int kvaser_usb_init_one(struct kvaser_usb *dev, int channel)
 755 {
 756         struct net_device *netdev;
 757         struct kvaser_usb_net_priv *priv;
 758         const struct kvaser_usb_driver_info *driver_info = dev->driver_info;
 759         const struct kvaser_usb_dev_ops *ops = driver_info->ops;
 760         int err;
 761
 762         if (ops->dev_reset_chip) {
 763                 err = ops->dev_reset_chip(dev, channel);
 764                 if (err)
 765                         return err;
 766         }
 767
 768         netdev = alloc_candev(sizeof(*priv) +
 769                               dev->max_tx_urbs * sizeof(*priv->tx_contexts),
 770                               dev->max_tx_urbs);
 771         if (!netdev) {
 772                 dev_err(&dev->intf->dev, "Cannot alloc candev\n");
 773                 return -ENOMEM;
 774         }
 775
 776         priv = netdev_priv(netdev);
 777
 778         init_usb_anchor(&priv->tx_submitted);
 779         init_completion(&priv->start_comp);
 780         init_completion(&priv->stop_comp);
 781         init_completion(&priv->flush_comp);
 782         init_completion(&priv->get_busparams_comp);
 783         priv->can.ctrlmode_supported = 0;
 784
 785         priv->dev = dev;
 786         priv->netdev = netdev;
 787         priv->channel = channel;
 788
 789         spin_lock_init(&priv->tx_contexts_lock);
 790         kvaser_usb_reset_tx_urb_contexts(priv);
 791
 792         priv->can.state = CAN_STATE_STOPPED;
 793         priv->can.clock.freq = dev->cfg->clock.freq;
 794         priv->can.bittiming_const = dev->cfg->bittiming_const;
 795         priv->can.do_set_bittiming = kvaser_usb_set_bittiming;
 796         priv->can.do_set_mode = ops->dev_set_mode;
 797         if ((driver_info->quirks & KVASER_USB_QUIRK_HAS_TXRX_ERRORS) ||
 798             (priv->dev->card_data.capabilities & KVASER_USB_CAP_BERR_CAP))
 799                 priv->can.do_get_berr_counter = ops->dev_get_berr_counter;
 800         if (driver_info->quirks & KVASER_USB_QUIRK_HAS_SILENT_MODE)
 801                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
 802
 803         priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported;
 804
 805         if (priv->can.ctrlmode_supported & CAN_CTRLMODE_FD) {
 806                 priv->can.data_bittiming_const = dev->cfg->data_bittiming_const;
 807                 priv->can.do_set_data_bittiming = kvaser_usb_set_data_bittiming;
 808         }
 809
 810         netdev->flags |= IFF_ECHO;
 811
 812         netdev->netdev_ops = &kvaser_usb_netdev_ops;
 813
 814         SET_NETDEV_DEV(netdev, &dev->intf->dev);
 815         netdev->dev_id = channel;
 816
 817         dev->nets[channel] = priv;
 818
 819         if (ops->dev_init_channel) {
 820                 err = ops->dev_init_channel(priv);
 821                 if (err)
 822                         goto err;
 823         }
 824
 825         err = register_candev(netdev);
 826         if (err) {
 827                 dev_err(&dev->intf->dev, "Failed to register CAN device\n");
 828                 goto err;
 829         }
 830
 831         netdev_dbg(netdev, "device registered\n");
 832
 833         return 0;
 834
 835 err:
 836         free_candev(netdev);
 837         dev->nets[channel] = NULL;
 838         return err;
 839 }
 840
 841 static int kvaser_usb_probe(struct usb_interface *intf,
 842                             const struct usb_device_id *id)
 843 {
 844         struct kvaser_usb *dev;
 845         int err;
 846         int i;
 847         const struct kvaser_usb_driver_info *driver_info;
 848         const struct kvaser_usb_dev_ops *ops;
 849
 850         driver_info = (const struct kvaser_usb_driver_info *)id->driver_info;
 851         if (!driver_info)
 852                 return -ENODEV;
 853
 854         dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL);
 855         if (!dev)
 856                 return -ENOMEM;
 857
 858         dev->intf = intf;
 859         dev->driver_info = driver_info;
 860         ops = driver_info->ops;
 861
 862         err = ops->dev_setup_endpoints(dev);
 863         if (err) {
 864                 dev_err(&intf->dev, "Cannot get usb endpoint(s)");
 865                 return err;
 866         }
 867
 868         dev->udev = interface_to_usbdev(intf);
 869
 870         init_usb_anchor(&dev->rx_submitted);
 871
 872         usb_set_intfdata(intf, dev);
 873
 874         dev->card_data.ctrlmode_supported = 0;
 875         dev->card_data.capabilities = 0;
 876         err = ops->dev_init_card(dev);
 877         if (err) {
 878                 dev_err(&intf->dev,
 879                         "Failed to initialize card, error %d\n", err);
 880                 return err;
 881         }
 882
 883         err = ops->dev_get_software_info(dev);
 884         if (err) {
 885                 dev_err(&intf->dev,
 886                         "Cannot get software info, error %d\n", err);
 887                 return err;
 888         }
 889
 890         if (ops->dev_get_software_details) {
 891                 err = ops->dev_get_software_details(dev);
 892                 if (err) {
 893                         dev_err(&intf->dev,
 894                                 "Cannot get software details, error %d\n", err);
 895                         return err;
 896                 }
 897         }
 898
 899         if (WARN_ON(!dev->cfg))
 900                 return -ENODEV;
 901
 902         dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n",
 903                 ((dev->fw_version >> 24) & 0xff),
 904                 ((dev->fw_version >> 16) & 0xff),
 905                 (dev->fw_version & 0xffff));
 906
 907         dev_dbg(&intf->dev, "Max outstanding tx = %d URBs\n", dev->max_tx_urbs);
 908
 909         err = ops->dev_get_card_info(dev);
 910         if (err) {
 911                 dev_err(&intf->dev, "Cannot get card info, error %d\n", err);
 912                 return err;
 913         }
 914
 915         if (ops->dev_get_capabilities) {
 916                 err = ops->dev_get_capabilities(dev);
 917                 if (err) {
 918                         dev_err(&intf->dev,
 919                                 "Cannot get capabilities, error %d\n", err);
 920                         kvaser_usb_remove_interfaces(dev);
 921                         return err;
 922                 }
 923         }
 924
 925         for (i = 0; i < dev->nchannels; i++) {
 926                 err = kvaser_usb_init_one(dev, i);
 927                 if (err) {
 928                         kvaser_usb_remove_interfaces(dev);
 929                         return err;
 930                 }
 931         }
 932
 933         return 0;
 934 }
 935
 936 static void kvaser_usb_disconnect(struct usb_interface *intf)
 937 {
 938         struct kvaser_usb *dev = usb_get_intfdata(intf);
 939
 940         usb_set_intfdata(intf, NULL);
 941
 942         if (!dev)
 943                 return;
 944
 945         kvaser_usb_remove_interfaces(dev);
 946 }
 947
 948 static struct usb_driver kvaser_usb_driver = {
 949         .name = "kvaser_usb",
 950         .probe = kvaser_usb_probe,
 951         .disconnect = kvaser_usb_disconnect,
 952         .id_table = kvaser_usb_table,
 953 };
 954
 955 module_usb_driver(kvaser_usb_driver);
 956
 957 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
 958 MODULE_AUTHOR("Kvaser AB <support@kvaser.com>");
 959 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
 960 MODULE_LICENSE("GPL v2");