drivers/net/can/usb/kvaser_usb.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License as
   4  * published by the Free Software Foundation version 2.
   5  *
   6  * Parts of this driver are based on the following:
   7  *  - Kvaser linux leaf driver (version 4.78)
   8  *  - CAN driver for esd CAN-USB/2
   9  *  - Kvaser linux usbcanII driver (version 5.3)
  10  *
  11  * Copyright (C) 2002-2006 KVASER AB, Sweden. All rights reserved.
  12  * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
  13  * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
  14  * Copyright (C) 2015 Valeo S.A.
  15  */
  16
  17 #include <linux/completion.h>
  18 #include <linux/module.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/usb.h>
  21
  22 #include <linux/can.h>
  23 #include <linux/can/dev.h>
  24 #include <linux/can/error.h>
  25
  26 #define MAX_TX_URBS                     16
  27 #define MAX_RX_URBS                     4
  28 #define START_TIMEOUT                   1000 /* msecs */
  29 #define STOP_TIMEOUT                    1000 /* msecs */
  30 #define USB_SEND_TIMEOUT                1000 /* msecs */
  31 #define USB_RECV_TIMEOUT                1000 /* msecs */
  32 #define RX_BUFFER_SIZE                  3072
  33 #define CAN_USB_CLOCK                   8000000
  34 #define MAX_NET_DEVICES                 3
  35 #define MAX_USBCAN_NET_DEVICES          2
  36
  37 /* Kvaser Leaf USB devices */
  38 #define KVASER_VENDOR_ID                0x0bfd
  39 #define USB_LEAF_DEVEL_PRODUCT_ID       10
  40 #define USB_LEAF_LITE_PRODUCT_ID        11
  41 #define USB_LEAF_PRO_PRODUCT_ID         12
  42 #define USB_LEAF_SPRO_PRODUCT_ID        14
  43 #define USB_LEAF_PRO_LS_PRODUCT_ID      15
  44 #define USB_LEAF_PRO_SWC_PRODUCT_ID     16
  45 #define USB_LEAF_PRO_LIN_PRODUCT_ID     17
  46 #define USB_LEAF_SPRO_LS_PRODUCT_ID     18
  47 #define USB_LEAF_SPRO_SWC_PRODUCT_ID    19
  48 #define USB_MEMO2_DEVEL_PRODUCT_ID      22
  49 #define USB_MEMO2_HSHS_PRODUCT_ID       23
  50 #define USB_UPRO_HSHS_PRODUCT_ID        24
  51 #define USB_LEAF_LITE_GI_PRODUCT_ID     25
  52 #define USB_LEAF_PRO_OBDII_PRODUCT_ID   26
  53 #define USB_MEMO2_HSLS_PRODUCT_ID       27
  54 #define USB_LEAF_LITE_CH_PRODUCT_ID     28
  55 #define USB_BLACKBIRD_SPRO_PRODUCT_ID   29
  56 #define USB_OEM_MERCURY_PRODUCT_ID      34
  57 #define USB_OEM_LEAF_PRODUCT_ID         35
  58 #define USB_CAN_R_PRODUCT_ID            39
  59 #define USB_LEAF_LITE_V2_PRODUCT_ID     288
  60 #define USB_MINI_PCIE_HS_PRODUCT_ID     289
  61
  62 static inline bool kvaser_is_leaf(const struct usb_device_id *id)
  63 {
  64         return id->idProduct >= USB_LEAF_DEVEL_PRODUCT_ID &&
  65                id->idProduct <= USB_MINI_PCIE_HS_PRODUCT_ID;
  66 }
  67
  68 /* Kvaser USBCan-II devices */
  69 #define USB_USBCAN_REVB_PRODUCT_ID      2
  70 #define USB_VCI2_PRODUCT_ID             3
  71 #define USB_USBCAN2_PRODUCT_ID          4
  72 #define USB_MEMORATOR_PRODUCT_ID        5
  73
  74 static inline bool kvaser_is_usbcan(const struct usb_device_id *id)
  75 {
  76         return id->idProduct >= USB_USBCAN_REVB_PRODUCT_ID &&
  77                id->idProduct <= USB_MEMORATOR_PRODUCT_ID;
  78 }
  79
  80 /* USB devices features */
  81 #define KVASER_HAS_SILENT_MODE          BIT(0)
  82 #define KVASER_HAS_TXRX_ERRORS          BIT(1)
  83
  84 /* Message header size */
  85 #define MSG_HEADER_LEN                  2
  86
  87 /* Can message flags */
  88 #define MSG_FLAG_ERROR_FRAME            BIT(0)
  89 #define MSG_FLAG_OVERRUN                BIT(1)
  90 #define MSG_FLAG_NERR                   BIT(2)
  91 #define MSG_FLAG_WAKEUP                 BIT(3)
  92 #define MSG_FLAG_REMOTE_FRAME           BIT(4)
  93 #define MSG_FLAG_RESERVED               BIT(5)
  94 #define MSG_FLAG_TX_ACK                 BIT(6)
  95 #define MSG_FLAG_TX_REQUEST             BIT(7)
  96
  97 /* Can states (M16C CxSTRH register) */
  98 #define M16C_STATE_BUS_RESET            BIT(0)
  99 #define M16C_STATE_BUS_ERROR            BIT(4)
 100 #define M16C_STATE_BUS_PASSIVE          BIT(5)
 101 #define M16C_STATE_BUS_OFF              BIT(6)
 102
 103 /* Can msg ids */
 104 #define CMD_RX_STD_MESSAGE              12
 105 #define CMD_TX_STD_MESSAGE              13
 106 #define CMD_RX_EXT_MESSAGE              14
 107 #define CMD_TX_EXT_MESSAGE              15
 108 #define CMD_SET_BUS_PARAMS              16
 109 #define CMD_GET_BUS_PARAMS              17
 110 #define CMD_GET_BUS_PARAMS_REPLY        18
 111 #define CMD_GET_CHIP_STATE              19
 112 #define CMD_CHIP_STATE_EVENT            20
 113 #define CMD_SET_CTRL_MODE               21
 114 #define CMD_GET_CTRL_MODE               22
 115 #define CMD_GET_CTRL_MODE_REPLY         23
 116 #define CMD_RESET_CHIP                  24
 117 #define CMD_RESET_CARD                  25
 118 #define CMD_START_CHIP                  26
 119 #define CMD_START_CHIP_REPLY            27
 120 #define CMD_STOP_CHIP                   28
 121 #define CMD_STOP_CHIP_REPLY             29
 122
 123 #define CMD_LEAF_GET_CARD_INFO2         32
 124 #define CMD_USBCAN_RESET_CLOCK          32
 125 #define CMD_USBCAN_CLOCK_OVERFLOW_EVENT 33
 126
 127 #define CMD_GET_CARD_INFO               34
 128 #define CMD_GET_CARD_INFO_REPLY         35
 129 #define CMD_GET_SOFTWARE_INFO           38
 130 #define CMD_GET_SOFTWARE_INFO_REPLY     39
 131 #define CMD_ERROR_EVENT                 45
 132 #define CMD_FLUSH_QUEUE                 48
 133 #define CMD_RESET_ERROR_COUNTER         49
 134 #define CMD_TX_ACKNOWLEDGE              50
 135 #define CMD_CAN_ERROR_EVENT             51
 136
 137 #define CMD_LEAF_USB_THROTTLE           77
 138 #define CMD_LEAF_LOG_MESSAGE            106
 139
 140 /* error factors */
 141 #define M16C_EF_ACKE                    BIT(0)
 142 #define M16C_EF_CRCE                    BIT(1)
 143 #define M16C_EF_FORME                   BIT(2)
 144 #define M16C_EF_STFE                    BIT(3)
 145 #define M16C_EF_BITE0                   BIT(4)
 146 #define M16C_EF_BITE1                   BIT(5)
 147 #define M16C_EF_RCVE                    BIT(6)
 148 #define M16C_EF_TRE                     BIT(7)
 149
 150 /* Only Leaf-based devices can report M16C error factors,
 151  * thus define our own error status flags for USBCANII
 152  */
 153 #define USBCAN_ERROR_STATE_NONE         0
 154 #define USBCAN_ERROR_STATE_TX_ERROR     BIT(0)
 155 #define USBCAN_ERROR_STATE_RX_ERROR     BIT(1)
 156 #define USBCAN_ERROR_STATE_BUSERROR     BIT(2)
 157
 158 /* bittiming parameters */
 159 #define KVASER_USB_TSEG1_MIN            1
 160 #define KVASER_USB_TSEG1_MAX            16
 161 #define KVASER_USB_TSEG2_MIN            1
 162 #define KVASER_USB_TSEG2_MAX            8
 163 #define KVASER_USB_SJW_MAX              4
 164 #define KVASER_USB_BRP_MIN              1
 165 #define KVASER_USB_BRP_MAX              64
 166 #define KVASER_USB_BRP_INC              1
 167
 168 /* ctrl modes */
 169 #define KVASER_CTRL_MODE_NORMAL         1
 170 #define KVASER_CTRL_MODE_SILENT         2
 171 #define KVASER_CTRL_MODE_SELFRECEPTION  3
 172 #define KVASER_CTRL_MODE_OFF            4
 173
 174 /* Extended CAN identifier flag */
 175 #define KVASER_EXTENDED_FRAME           BIT(31)
 176
 177 /* Kvaser USB CAN dongles are divided into two major families:
 178  * - Leaf: Based on Renesas M32C, running firmware labeled as 'filo'
 179  * - UsbcanII: Based on Renesas M16C, running firmware labeled as 'helios'
 180  */
 181 enum kvaser_usb_family {
 182         KVASER_LEAF,
 183         KVASER_USBCAN,
 184 };
 185
 186 struct kvaser_msg_simple {
 187         u8 tid;
 188         u8 channel;
 189 } __packed;
 190
 191 struct kvaser_msg_cardinfo {
 192         u8 tid;
 193         u8 nchannels;
 194         union {
 195                 struct {
 196                         __le32 serial_number;
 197                         __le32 padding;
 198                 } __packed leaf0;
 199                 struct {
 200                         __le32 serial_number_low;
 201                         __le32 serial_number_high;
 202                 } __packed usbcan0;
 203         } __packed;
 204         __le32 clock_resolution;
 205         __le32 mfgdate;
 206         u8 ean[8];
 207         u8 hw_revision;
 208         union {
 209                 struct {
 210                         u8 usb_hs_mode;
 211                 } __packed leaf1;
 212                 struct {
 213                         u8 padding;
 214                 } __packed usbcan1;
 215         } __packed;
 216         __le16 padding;
 217 } __packed;
 218
 219 struct kvaser_msg_cardinfo2 {
 220         u8 tid;
 221         u8 reserved;
 222         u8 pcb_id[24];
 223         __le32 oem_unlock_code;
 224 } __packed;
 225
 226 struct leaf_msg_softinfo {
 227         u8 tid;
 228         u8 padding0;
 229         __le32 sw_options;
 230         __le32 fw_version;
 231         __le16 max_outstanding_tx;
 232         __le16 padding1[9];
 233 } __packed;
 234
 235 struct usbcan_msg_softinfo {
 236         u8 tid;
 237         u8 fw_name[5];
 238         __le16 max_outstanding_tx;
 239         u8 padding[6];
 240         __le32 fw_version;
 241         __le16 checksum;
 242         __le16 sw_options;
 243 } __packed;
 244
 245 struct kvaser_msg_busparams {
 246         u8 tid;
 247         u8 channel;
 248         __le32 bitrate;
 249         u8 tseg1;
 250         u8 tseg2;
 251         u8 sjw;
 252         u8 no_samp;
 253 } __packed;
 254
 255 struct kvaser_msg_tx_can {
 256         u8 channel;
 257         u8 tid;
 258         u8 msg[14];
 259         union {
 260                 struct {
 261                         u8 padding;
 262                         u8 flags;
 263                 } __packed leaf;
 264                 struct {
 265                         u8 flags;
 266                         u8 padding;
 267                 } __packed usbcan;
 268         } __packed;
 269 } __packed;
 270
 271 struct kvaser_msg_rx_can_header {
 272         u8 channel;
 273         u8 flag;
 274 } __packed;
 275
 276 struct leaf_msg_rx_can {
 277         u8 channel;
 278         u8 flag;
 279
 280         __le16 time[3];
 281         u8 msg[14];
 282 } __packed;
 283
 284 struct usbcan_msg_rx_can {
 285         u8 channel;
 286         u8 flag;
 287
 288         u8 msg[14];
 289         __le16 time;
 290 } __packed;
 291
 292 struct leaf_msg_chip_state_event {
 293         u8 tid;
 294         u8 channel;
 295
 296         __le16 time[3];
 297         u8 tx_errors_count;
 298         u8 rx_errors_count;
 299
 300         u8 status;
 301         u8 padding[3];
 302 } __packed;
 303
 304 struct usbcan_msg_chip_state_event {
 305         u8 tid;
 306         u8 channel;
 307
 308         u8 tx_errors_count;
 309         u8 rx_errors_count;
 310         __le16 time;
 311
 312         u8 status;
 313         u8 padding[3];
 314 } __packed;
 315
 316 struct kvaser_msg_tx_acknowledge_header {
 317         u8 channel;
 318         u8 tid;
 319 } __packed;
 320
 321 struct leaf_msg_tx_acknowledge {
 322         u8 channel;
 323         u8 tid;
 324
 325         __le16 time[3];
 326         u8 flags;
 327         u8 time_offset;
 328 } __packed;
 329
 330 struct usbcan_msg_tx_acknowledge {
 331         u8 channel;
 332         u8 tid;
 333
 334         __le16 time;
 335         __le16 padding;
 336 } __packed;
 337
 338 struct leaf_msg_error_event {
 339         u8 tid;
 340         u8 flags;
 341         __le16 time[3];
 342         u8 channel;
 343         u8 padding;
 344         u8 tx_errors_count;
 345         u8 rx_errors_count;
 346         u8 status;
 347         u8 error_factor;
 348 } __packed;
 349
 350 struct usbcan_msg_error_event {
 351         u8 tid;
 352         u8 padding;
 353         u8 tx_errors_count_ch0;
 354         u8 rx_errors_count_ch0;
 355         u8 tx_errors_count_ch1;
 356         u8 rx_errors_count_ch1;
 357         u8 status_ch0;
 358         u8 status_ch1;
 359         __le16 time;
 360 } __packed;
 361
 362 struct kvaser_msg_ctrl_mode {
 363         u8 tid;
 364         u8 channel;
 365         u8 ctrl_mode;
 366         u8 padding[3];
 367 } __packed;
 368
 369 struct kvaser_msg_flush_queue {
 370         u8 tid;
 371         u8 channel;
 372         u8 flags;
 373         u8 padding[3];
 374 } __packed;
 375
 376 struct leaf_msg_log_message {
 377         u8 channel;
 378         u8 flags;
 379         __le16 time[3];
 380         u8 dlc;
 381         u8 time_offset;
 382         __le32 id;
 383         u8 data[8];
 384 } __packed;
 385
 386 struct kvaser_msg {
 387         u8 len;
 388         u8 id;
 389         union   {
 390                 struct kvaser_msg_simple simple;
 391                 struct kvaser_msg_cardinfo cardinfo;
 392                 struct kvaser_msg_cardinfo2 cardinfo2;
 393                 struct kvaser_msg_busparams busparams;
 394
 395                 struct kvaser_msg_rx_can_header rx_can_header;
 396                 struct kvaser_msg_tx_acknowledge_header tx_acknowledge_header;
 397
 398                 union {
 399                         struct leaf_msg_softinfo softinfo;
 400                         struct leaf_msg_rx_can rx_can;
 401                         struct leaf_msg_chip_state_event chip_state_event;
 402                         struct leaf_msg_tx_acknowledge tx_acknowledge;
 403                         struct leaf_msg_error_event error_event;
 404                         struct leaf_msg_log_message log_message;
 405                 } __packed leaf;
 406
 407                 union {
 408                         struct usbcan_msg_softinfo softinfo;
 409                         struct usbcan_msg_rx_can rx_can;
 410                         struct usbcan_msg_chip_state_event chip_state_event;
 411                         struct usbcan_msg_tx_acknowledge tx_acknowledge;
 412                         struct usbcan_msg_error_event error_event;
 413                 } __packed usbcan;
 414
 415                 struct kvaser_msg_tx_can tx_can;
 416                 struct kvaser_msg_ctrl_mode ctrl_mode;
 417                 struct kvaser_msg_flush_queue flush_queue;
 418         } u;
 419 } __packed;
 420
 421 /* Summary of a kvaser error event, for a unified Leaf/Usbcan error
 422  * handling. Some discrepancies between the two families exist:
 423  *
 424  * - USBCAN firmware does not report M16C "error factors"
 425  * - USBCAN controllers has difficulties reporting if the raised error
 426  *   event is for ch0 or ch1. They leave such arbitration to the OS
 427  *   driver by letting it compare error counters with previous values
 428  *   and decide the error event's channel. Thus for USBCAN, the channel
 429  *   field is only advisory.
 430  */
 431 struct kvaser_usb_error_summary {
 432         u8 channel, status, txerr, rxerr;
 433         union {
 434                 struct {
 435                         u8 error_factor;
 436                 } leaf;
 437                 struct {
 438                         u8 other_ch_status;
 439                         u8 error_state;
 440                 } usbcan;
 441         };
 442 };
 443
 444 struct kvaser_usb_tx_urb_context {
 445         struct kvaser_usb_net_priv *priv;
 446         u32 echo_index;
 447         int dlc;
 448 };
 449
 450 struct kvaser_usb {
 451         struct usb_device *udev;
 452         struct kvaser_usb_net_priv *nets[MAX_NET_DEVICES];
 453
 454         struct usb_endpoint_descriptor *bulk_in, *bulk_out;
 455         struct usb_anchor rx_submitted;
 456
 457         u32 fw_version;
 458         unsigned int nchannels;
 459         enum kvaser_usb_family family;
 460
 461         bool rxinitdone;
 462         void *rxbuf[MAX_RX_URBS];
 463         dma_addr_t rxbuf_dma[MAX_RX_URBS];
 464 };
 465
 466 struct kvaser_usb_net_priv {
 467         struct can_priv can;
 468
 469         atomic_t active_tx_urbs;
 470         struct usb_anchor tx_submitted;
 471         struct kvaser_usb_tx_urb_context tx_contexts[MAX_TX_URBS];
 472
 473         struct completion start_comp, stop_comp;
 474
 475         struct kvaser_usb *dev;
 476         struct net_device *netdev;
 477         int channel;
 478
 479         struct can_berr_counter bec;
 480 };
 481
 482 static const struct usb_device_id kvaser_usb_table[] = {
 483         /* Leaf family IDs */
 484         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID) },
 485         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID) },
 486         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID),
 487                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 488                                KVASER_HAS_SILENT_MODE },
 489         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID),
 490                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 491                                KVASER_HAS_SILENT_MODE },
 492         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID),
 493                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 494                                KVASER_HAS_SILENT_MODE },
 495         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID),
 496                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 497                                KVASER_HAS_SILENT_MODE },
 498         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID),
 499                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 500                                KVASER_HAS_SILENT_MODE },
 501         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID),
 502                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 503                                KVASER_HAS_SILENT_MODE },
 504         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID),
 505                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 506                                KVASER_HAS_SILENT_MODE },
 507         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID),
 508                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 509                                KVASER_HAS_SILENT_MODE },
 510         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID),
 511                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 512                                KVASER_HAS_SILENT_MODE },
 513         { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID),
 514                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 515         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID) },
 516         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID),
 517                 .driver_info = KVASER_HAS_TXRX_ERRORS |
 518                                KVASER_HAS_SILENT_MODE },
 519         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID),
 520                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 521         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID),
 522                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 523         { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID),
 524                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 525         { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID),
 526                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 527         { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID),
 528                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 529         { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID),
 530                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 531         { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID) },
 532         { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID) },
 533
 534         /* USBCANII family IDs */
 535         { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID),
 536                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 537         { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_REVB_PRODUCT_ID),
 538                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 539         { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMORATOR_PRODUCT_ID),
 540                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 541         { USB_DEVICE(KVASER_VENDOR_ID, USB_VCI2_PRODUCT_ID),
 542                 .driver_info = KVASER_HAS_TXRX_ERRORS },
 543
 544         { }
 545 };
 546 MODULE_DEVICE_TABLE(usb, kvaser_usb_table);
 547
 548 static inline int kvaser_usb_send_msg(const struct kvaser_usb *dev,
 549                                       struct kvaser_msg *msg)
 550 {
 551         int actual_len;
 552
 553         return usb_bulk_msg(dev->udev,
 554                             usb_sndbulkpipe(dev->udev,
 555                                         dev->bulk_out->bEndpointAddress),
 556                             msg, msg->len, &actual_len,
 557                             USB_SEND_TIMEOUT);
 558 }
 559
 560 static int kvaser_usb_wait_msg(const struct kvaser_usb *dev, u8 id,
 561                                struct kvaser_msg *msg)
 562 {
 563         struct kvaser_msg *tmp;
 564         void *buf;
 565         int actual_len;
 566         int err;
 567         int pos;
 568         unsigned long to = jiffies + msecs_to_jiffies(USB_RECV_TIMEOUT);
 569
 570         buf = kzalloc(RX_BUFFER_SIZE, GFP_KERNEL);
 571         if (!buf)
 572                 return -ENOMEM;
 573
 574         do {
 575                 err = usb_bulk_msg(dev->udev,
 576                                    usb_rcvbulkpipe(dev->udev,
 577                                         dev->bulk_in->bEndpointAddress),
 578                                    buf, RX_BUFFER_SIZE, &actual_len,
 579                                    USB_RECV_TIMEOUT);
 580                 if (err < 0)
 581                         goto end;
 582
 583                 pos = 0;
 584                 while (pos <= actual_len - MSG_HEADER_LEN) {
 585                         tmp = buf + pos;
 586
 587                         if (!tmp->len)
 588                                 break;
 589
 590                         if (pos + tmp->len > actual_len) {
 591                                 dev_err(dev->udev->dev.parent,
 592                                         "Format error\n");
 593                                 break;
 594                         }
 595
 596                         if (tmp->id == id) {
 597                                 memcpy(msg, tmp, tmp->len);
 598                                 goto end;
 599                         }
 600
 601                         pos += tmp->len;
 602                 }
 603         } while (time_before(jiffies, to));
 604
 605         err = -EINVAL;
 606
 607 end:
 608         kfree(buf);
 609
 610         return err;
 611 }
 612
 613 static int kvaser_usb_send_simple_msg(const struct kvaser_usb *dev,
 614                                       u8 msg_id, int channel)
 615 {
 616         struct kvaser_msg *msg;
 617         int rc;
 618
 619         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 620         if (!msg)
 621                 return -ENOMEM;
 622
 623         msg->id = msg_id;
 624         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
 625         msg->u.simple.channel = channel;
 626         msg->u.simple.tid = 0xff;
 627
 628         rc = kvaser_usb_send_msg(dev, msg);
 629
 630         kfree(msg);
 631         return rc;
 632 }
 633
 634 static int kvaser_usb_get_software_info(struct kvaser_usb *dev)
 635 {
 636         struct kvaser_msg msg;
 637         int err;
 638
 639         err = kvaser_usb_send_simple_msg(dev, CMD_GET_SOFTWARE_INFO, 0);
 640         if (err)
 641                 return err;
 642
 643         err = kvaser_usb_wait_msg(dev, CMD_GET_SOFTWARE_INFO_REPLY, &msg);
 644         if (err)
 645                 return err;
 646
 647         switch (dev->family) {
 648         case KVASER_LEAF:
 649                 dev->fw_version = le32_to_cpu(msg.u.leaf.softinfo.fw_version);
 650                 break;
 651         case KVASER_USBCAN:
 652                 dev->fw_version = le32_to_cpu(msg.u.usbcan.softinfo.fw_version);
 653                 break;
 654         }
 655
 656         return 0;
 657 }
 658
 659 static int kvaser_usb_get_card_info(struct kvaser_usb *dev)
 660 {
 661         struct kvaser_msg msg;
 662         int err;
 663
 664         err = kvaser_usb_send_simple_msg(dev, CMD_GET_CARD_INFO, 0);
 665         if (err)
 666                 return err;
 667
 668         err = kvaser_usb_wait_msg(dev, CMD_GET_CARD_INFO_REPLY, &msg);
 669         if (err)
 670                 return err;
 671
 672         dev->nchannels = msg.u.cardinfo.nchannels;
 673         if ((dev->nchannels > MAX_NET_DEVICES) ||
 674             (dev->family == KVASER_USBCAN &&
 675              dev->nchannels > MAX_USBCAN_NET_DEVICES))
 676                 return -EINVAL;
 677
 678         return 0;
 679 }
 680
 681 static void kvaser_usb_tx_acknowledge(const struct kvaser_usb *dev,
 682                                       const struct kvaser_msg *msg)
 683 {
 684         struct net_device_stats *stats;
 685         struct kvaser_usb_tx_urb_context *context;
 686         struct kvaser_usb_net_priv *priv;
 687         struct sk_buff *skb;
 688         struct can_frame *cf;
 689         u8 channel, tid;
 690
 691         channel = msg->u.tx_acknowledge_header.channel;
 692         tid = msg->u.tx_acknowledge_header.tid;
 693
 694         if (channel >= dev->nchannels) {
 695                 dev_err(dev->udev->dev.parent,
 696                         "Invalid channel number (%d)\n", channel);
 697                 return;
 698         }
 699
 700         priv = dev->nets[channel];
 701
 702         if (!netif_device_present(priv->netdev))
 703                 return;
 704
 705         stats = &priv->netdev->stats;
 706
 707         context = &priv->tx_contexts[tid % MAX_TX_URBS];
 708
 709         /* Sometimes the state change doesn't come after a bus-off event */
 710         if (priv->can.restart_ms &&
 711             (priv->can.state >= CAN_STATE_BUS_OFF)) {
 712                 skb = alloc_can_err_skb(priv->netdev, &cf);
 713                 if (skb) {
 714                         cf->can_id |= CAN_ERR_RESTARTED;
 715
 716                         stats->rx_packets++;
 717                         stats->rx_bytes += cf->can_dlc;
 718                         netif_rx(skb);
 719                 } else {
 720                         netdev_err(priv->netdev,
 721                                    "No memory left for err_skb\n");
 722                 }
 723
 724                 priv->can.can_stats.restarts++;
 725                 netif_carrier_on(priv->netdev);
 726
 727                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
 728         }
 729
 730         stats->tx_packets++;
 731         stats->tx_bytes += context->dlc;
 732         can_get_echo_skb(priv->netdev, context->echo_index);
 733
 734         context->echo_index = MAX_TX_URBS;
 735         atomic_dec(&priv->active_tx_urbs);
 736
 737         netif_wake_queue(priv->netdev);
 738 }
 739
 740 static void kvaser_usb_simple_msg_callback(struct urb *urb)
 741 {
 742         struct net_device *netdev = urb->context;
 743
 744         kfree(urb->transfer_buffer);
 745
 746         if (urb->status)
 747                 netdev_warn(netdev, "urb status received: %d\n",
 748                             urb->status);
 749 }
 750
 751 static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv *priv,
 752                                        u8 msg_id)
 753 {
 754         struct kvaser_usb *dev = priv->dev;
 755         struct net_device *netdev = priv->netdev;
 756         struct kvaser_msg *msg;
 757         struct urb *urb;
 758         void *buf;
 759         int err;
 760
 761         urb = usb_alloc_urb(0, GFP_ATOMIC);
 762         if (!urb) {
 763                 netdev_err(netdev, "No memory left for URBs\n");
 764                 return -ENOMEM;
 765         }
 766
 767         buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
 768         if (!buf) {
 769                 usb_free_urb(urb);
 770                 return -ENOMEM;
 771         }
 772
 773         msg = (struct kvaser_msg *)buf;
 774         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
 775         msg->id = msg_id;
 776         msg->u.simple.channel = priv->channel;
 777
 778         usb_fill_bulk_urb(urb, dev->udev,
 779                           usb_sndbulkpipe(dev->udev,
 780                                           dev->bulk_out->bEndpointAddress),
 781                           buf, msg->len,
 782                           kvaser_usb_simple_msg_callback, netdev);
 783         usb_anchor_urb(urb, &priv->tx_submitted);
 784
 785         err = usb_submit_urb(urb, GFP_ATOMIC);
 786         if (err) {
 787                 netdev_err(netdev, "Error transmitting URB\n");
 788                 usb_unanchor_urb(urb);
 789                 usb_free_urb(urb);
 790                 kfree(buf);
 791                 return err;
 792         }
 793
 794         usb_free_urb(urb);
 795
 796         return 0;
 797 }
 798
 799 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv)
 800 {
 801         int i;
 802
 803         usb_kill_anchored_urbs(&priv->tx_submitted);
 804         atomic_set(&priv->active_tx_urbs, 0);
 805
 806         for (i = 0; i < MAX_TX_URBS; i++)
 807                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
 808 }
 809
 810 static void kvaser_usb_rx_error_update_can_state(struct kvaser_usb_net_priv *priv,
 811                                                  const struct kvaser_usb_error_summary *es,
 812                                                  struct can_frame *cf)
 813 {
 814         struct kvaser_usb *dev = priv->dev;
 815         struct net_device_stats *stats = &priv->netdev->stats;
 816         enum can_state cur_state, new_state, tx_state, rx_state;
 817
 818         netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status);
 819
 820         new_state = cur_state = priv->can.state;
 821
 822         if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET))
 823                 new_state = CAN_STATE_BUS_OFF;
 824         else if (es->status & M16C_STATE_BUS_PASSIVE)
 825                 new_state = CAN_STATE_ERROR_PASSIVE;
 826         else if (es->status & M16C_STATE_BUS_ERROR) {
 827                 /* Guard against spurious error events after a busoff */
 828                 if (cur_state < CAN_STATE_BUS_OFF) {
 829                         if ((es->txerr >= 128) || (es->rxerr >= 128))
 830                                 new_state = CAN_STATE_ERROR_PASSIVE;
 831                         else if ((es->txerr >= 96) || (es->rxerr >= 96))
 832                                 new_state = CAN_STATE_ERROR_WARNING;
 833                         else if (cur_state > CAN_STATE_ERROR_ACTIVE)
 834                                 new_state = CAN_STATE_ERROR_ACTIVE;
 835                 }
 836         }
 837
 838         if (!es->status)
 839                 new_state = CAN_STATE_ERROR_ACTIVE;
 840
 841         if (new_state != cur_state) {
 842                 tx_state = (es->txerr >= es->rxerr) ? new_state : 0;
 843                 rx_state = (es->txerr <= es->rxerr) ? new_state : 0;
 844
 845                 can_change_state(priv->netdev, cf, tx_state, rx_state);
 846         }
 847
 848         if (priv->can.restart_ms &&
 849             (cur_state >= CAN_STATE_BUS_OFF) &&
 850             (new_state < CAN_STATE_BUS_OFF)) {
 851                 priv->can.can_stats.restarts++;
 852         }
 853
 854         switch (dev->family) {
 855         case KVASER_LEAF:
 856                 if (es->leaf.error_factor) {
 857                         priv->can.can_stats.bus_error++;
 858                         stats->rx_errors++;
 859                 }
 860                 break;
 861         case KVASER_USBCAN:
 862                 if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR)
 863                         stats->tx_errors++;
 864                 if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR)
 865                         stats->rx_errors++;
 866                 if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR) {
 867                         priv->can.can_stats.bus_error++;
 868                 }
 869                 break;
 870         }
 871
 872         priv->bec.txerr = es->txerr;
 873         priv->bec.rxerr = es->rxerr;
 874 }
 875
 876 static void kvaser_usb_rx_error(const struct kvaser_usb *dev,
 877                                 const struct kvaser_usb_error_summary *es)
 878 {
 879         struct can_frame *cf, tmp_cf = { .can_id = CAN_ERR_FLAG, .can_dlc = CAN_ERR_DLC };
 880         struct sk_buff *skb;
 881         struct net_device_stats *stats;
 882         struct kvaser_usb_net_priv *priv;
 883         enum can_state old_state, new_state;
 884
 885         if (es->channel >= dev->nchannels) {
 886                 dev_err(dev->udev->dev.parent,
 887                         "Invalid channel number (%d)\n", es->channel);
 888                 return;
 889         }
 890
 891         priv = dev->nets[es->channel];
 892         stats = &priv->netdev->stats;
 893
 894         /* Update all of the can interface's state and error counters before
 895          * trying any memory allocation that can actually fail with -ENOMEM.
 896          *
 897          * We send a temporary stack-allocated error can frame to
 898          * can_change_state() for the very same reason.
 899          *
 900          * TODO: Split can_change_state() responsibility between updating the
 901          * can interface's state and counters, and the setting up of can error
 902          * frame ID and data to userspace. Remove stack allocation afterwards.
 903          */
 904         old_state = priv->can.state;
 905         kvaser_usb_rx_error_update_can_state(priv, es, &tmp_cf);
 906         new_state = priv->can.state;
 907
 908         skb = alloc_can_err_skb(priv->netdev, &cf);
 909         if (!skb) {
 910                 stats->rx_dropped++;
 911                 return;
 912         }
 913         memcpy(cf, &tmp_cf, sizeof(*cf));
 914
 915         if (new_state != old_state) {
 916                 if (es->status &
 917                     (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
 918                         if (!priv->can.restart_ms)
 919                                 kvaser_usb_simple_msg_async(priv, CMD_STOP_CHIP);
 920                         netif_carrier_off(priv->netdev);
 921                 }
 922
 923                 if (priv->can.restart_ms &&
 924                     (old_state >= CAN_STATE_BUS_OFF) &&
 925                     (new_state < CAN_STATE_BUS_OFF)) {
 926                         cf->can_id |= CAN_ERR_RESTARTED;
 927                         netif_carrier_on(priv->netdev);
 928                 }
 929         }
 930
 931         switch (dev->family) {
 932         case KVASER_LEAF:
 933                 if (es->leaf.error_factor) {
 934                         cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
 935
 936                         if (es->leaf.error_factor & M16C_EF_ACKE)
 937                                 cf->data[3] |= (CAN_ERR_PROT_LOC_ACK);
 938                         if (es->leaf.error_factor & M16C_EF_CRCE)
 939                                 cf->data[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ |
 940                                                 CAN_ERR_PROT_LOC_CRC_DEL);
 941                         if (es->leaf.error_factor & M16C_EF_FORME)
 942                                 cf->data[2] |= CAN_ERR_PROT_FORM;
 943                         if (es->leaf.error_factor & M16C_EF_STFE)
 944                                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 945                         if (es->leaf.error_factor & M16C_EF_BITE0)
 946                                 cf->data[2] |= CAN_ERR_PROT_BIT0;
 947                         if (es->leaf.error_factor & M16C_EF_BITE1)
 948                                 cf->data[2] |= CAN_ERR_PROT_BIT1;
 949                         if (es->leaf.error_factor & M16C_EF_TRE)
 950                                 cf->data[2] |= CAN_ERR_PROT_TX;
 951                 }
 952                 break;
 953         case KVASER_USBCAN:
 954                 if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR) {
 955                         cf->can_id |= CAN_ERR_BUSERROR;
 956                 }
 957                 break;
 958         }
 959
 960         cf->data[6] = es->txerr;
 961         cf->data[7] = es->rxerr;
 962
 963         stats->rx_packets++;
 964         stats->rx_bytes += cf->can_dlc;
 965         netif_rx(skb);
 966 }
 967
 968 /* For USBCAN, report error to userspace iff the channels's errors counter
 969  * has changed, or we're the only channel seeing a bus error state.
 970  */
 971 static void kvaser_usbcan_conditionally_rx_error(const struct kvaser_usb *dev,
 972                                                  struct kvaser_usb_error_summary *es)
 973 {
 974         struct kvaser_usb_net_priv *priv;
 975         int channel;
 976         bool report_error;
 977
 978         channel = es->channel;
 979         if (channel >= dev->nchannels) {
 980                 dev_err(dev->udev->dev.parent,
 981                         "Invalid channel number (%d)\n", channel);
 982                 return;
 983         }
 984
 985         priv = dev->nets[channel];
 986         report_error = false;
 987
 988         if (es->txerr != priv->bec.txerr) {
 989                 es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR;
 990                 report_error = true;
 991         }
 992         if (es->rxerr != priv->bec.rxerr) {
 993                 es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR;
 994                 report_error = true;
 995         }
 996         if ((es->status & M16C_STATE_BUS_ERROR) &&
 997             !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) {
 998                 es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR;
 999                 report_error = true;
1000         }
1001
1002         if (report_error)
1003                 kvaser_usb_rx_error(dev, es);
1004 }
1005
1006 static void kvaser_usbcan_rx_error(const struct kvaser_usb *dev,
1007                                    const struct kvaser_msg *msg)
1008 {
1009         struct kvaser_usb_error_summary es = { };
1010
1011         switch (msg->id) {
1012         /* Sometimes errors are sent as unsolicited chip state events */
1013         case CMD_CHIP_STATE_EVENT:
1014                 es.channel = msg->u.usbcan.chip_state_event.channel;
1015                 es.status =  msg->u.usbcan.chip_state_event.status;
1016                 es.txerr = msg->u.usbcan.chip_state_event.tx_errors_count;
1017                 es.rxerr = msg->u.usbcan.chip_state_event.rx_errors_count;
1018                 kvaser_usbcan_conditionally_rx_error(dev, &es);
1019                 break;
1020
1021         case CMD_CAN_ERROR_EVENT:
1022                 es.channel = 0;
1023                 es.status = msg->u.usbcan.error_event.status_ch0;
1024                 es.txerr = msg->u.usbcan.error_event.tx_errors_count_ch0;
1025                 es.rxerr = msg->u.usbcan.error_event.rx_errors_count_ch0;
1026                 es.usbcan.other_ch_status =
1027                         msg->u.usbcan.error_event.status_ch1;
1028                 kvaser_usbcan_conditionally_rx_error(dev, &es);
1029
1030                 /* The USBCAN firmware supports up to 2 channels.
1031                  * Now that ch0 was checked, check if ch1 has any errors.
1032                  */
1033                 if (dev->nchannels == MAX_USBCAN_NET_DEVICES) {
1034                         es.channel = 1;
1035                         es.status = msg->u.usbcan.error_event.status_ch1;
1036                         es.txerr = msg->u.usbcan.error_event.tx_errors_count_ch1;
1037                         es.rxerr = msg->u.usbcan.error_event.rx_errors_count_ch1;
1038                         es.usbcan.other_ch_status =
1039                                 msg->u.usbcan.error_event.status_ch0;
1040                         kvaser_usbcan_conditionally_rx_error(dev, &es);
1041                 }
1042                 break;
1043
1044         default:
1045                 dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n",
1046                         msg->id);
1047         }
1048 }
1049
1050 static void kvaser_leaf_rx_error(const struct kvaser_usb *dev,
1051                                  const struct kvaser_msg *msg)
1052 {
1053         struct kvaser_usb_error_summary es = { };
1054
1055         switch (msg->id) {
1056         case CMD_CAN_ERROR_EVENT:
1057                 es.channel = msg->u.leaf.error_event.channel;
1058                 es.status =  msg->u.leaf.error_event.status;
1059                 es.txerr = msg->u.leaf.error_event.tx_errors_count;
1060                 es.rxerr = msg->u.leaf.error_event.rx_errors_count;
1061                 es.leaf.error_factor = msg->u.leaf.error_event.error_factor;
1062                 break;
1063         case CMD_LEAF_LOG_MESSAGE:
1064                 es.channel = msg->u.leaf.log_message.channel;
1065                 es.status = msg->u.leaf.log_message.data[0];
1066                 es.txerr = msg->u.leaf.log_message.data[2];
1067                 es.rxerr = msg->u.leaf.log_message.data[3];
1068                 es.leaf.error_factor = msg->u.leaf.log_message.data[1];
1069                 break;
1070         case CMD_CHIP_STATE_EVENT:
1071                 es.channel = msg->u.leaf.chip_state_event.channel;
1072                 es.status =  msg->u.leaf.chip_state_event.status;
1073                 es.txerr = msg->u.leaf.chip_state_event.tx_errors_count;
1074                 es.rxerr = msg->u.leaf.chip_state_event.rx_errors_count;
1075                 es.leaf.error_factor = 0;
1076                 break;
1077         default:
1078                 dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n",
1079                         msg->id);
1080                 return;
1081         }
1082
1083         kvaser_usb_rx_error(dev, &es);
1084 }
1085
1086 static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv *priv,
1087                                   const struct kvaser_msg *msg)
1088 {
1089         struct can_frame *cf;
1090         struct sk_buff *skb;
1091         struct net_device_stats *stats = &priv->netdev->stats;
1092
1093         if (msg->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
1094                                          MSG_FLAG_NERR)) {
1095                 netdev_err(priv->netdev, "Unknow error (flags: 0x%02x)\n",
1096                            msg->u.rx_can_header.flag);
1097
1098                 stats->rx_errors++;
1099                 return;
1100         }
1101
1102         if (msg->u.rx_can_header.flag & MSG_FLAG_OVERRUN) {
1103                 stats->rx_over_errors++;
1104                 stats->rx_errors++;
1105
1106                 skb = alloc_can_err_skb(priv->netdev, &cf);
1107                 if (!skb) {
1108                         stats->rx_dropped++;
1109                         return;
1110                 }
1111
1112                 cf->can_id |= CAN_ERR_CRTL;
1113                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
1114
1115                 stats->rx_packets++;
1116                 stats->rx_bytes += cf->can_dlc;
1117                 netif_rx(skb);
1118         }
1119 }
1120
1121 static void kvaser_usb_rx_can_msg(const struct kvaser_usb *dev,
1122                                   const struct kvaser_msg *msg)
1123 {
1124         struct kvaser_usb_net_priv *priv;
1125         struct can_frame *cf;
1126         struct sk_buff *skb;
1127         struct net_device_stats *stats;
1128         u8 channel = msg->u.rx_can_header.channel;
1129         const u8 *rx_msg = NULL;        /* GCC */
1130
1131         if (channel >= dev->nchannels) {
1132                 dev_err(dev->udev->dev.parent,
1133                         "Invalid channel number (%d)\n", channel);
1134                 return;
1135         }
1136
1137         priv = dev->nets[channel];
1138         stats = &priv->netdev->stats;
1139
1140         if ((msg->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
1141             (dev->family == KVASER_LEAF && msg->id == CMD_LEAF_LOG_MESSAGE)) {
1142                 kvaser_leaf_rx_error(dev, msg);
1143                 return;
1144         } else if (msg->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
1145                                                 MSG_FLAG_NERR |
1146                                                 MSG_FLAG_OVERRUN)) {
1147                 kvaser_usb_rx_can_err(priv, msg);
1148                 return;
1149         } else if (msg->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
1150                 netdev_warn(priv->netdev,
1151                             "Unhandled frame (flags: 0x%02x)",
1152                             msg->u.rx_can_header.flag);
1153                 return;
1154         }
1155
1156         switch (dev->family) {
1157         case KVASER_LEAF:
1158                 rx_msg = msg->u.leaf.rx_can.msg;
1159                 break;
1160         case KVASER_USBCAN:
1161                 rx_msg = msg->u.usbcan.rx_can.msg;
1162                 break;
1163         }
1164
1165         skb = alloc_can_skb(priv->netdev, &cf);
1166         if (!skb) {
1167                 stats->tx_dropped++;
1168                 return;
1169         }
1170
1171         if (dev->family == KVASER_LEAF && msg->id == CMD_LEAF_LOG_MESSAGE) {
1172                 cf->can_id = le32_to_cpu(msg->u.leaf.log_message.id);
1173                 if (cf->can_id & KVASER_EXTENDED_FRAME)
1174                         cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG;
1175                 else
1176                         cf->can_id &= CAN_SFF_MASK;
1177
1178                 cf->can_dlc = get_can_dlc(msg->u.leaf.log_message.dlc);
1179
1180                 if (msg->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
1181                         cf->can_id |= CAN_RTR_FLAG;
1182                 else
1183                         memcpy(cf->data, &msg->u.leaf.log_message.data,
1184                                cf->can_dlc);
1185         } else {
1186                 cf->can_id = ((rx_msg[0] & 0x1f) << 6) | (rx_msg[1] & 0x3f);
1187
1188                 if (msg->id == CMD_RX_EXT_MESSAGE) {
1189                         cf->can_id <<= 18;
1190                         cf->can_id |= ((rx_msg[2] & 0x0f) << 14) |
1191                                       ((rx_msg[3] & 0xff) << 6) |
1192                                       (rx_msg[4] & 0x3f);
1193                         cf->can_id |= CAN_EFF_FLAG;
1194                 }
1195
1196                 cf->can_dlc = get_can_dlc(rx_msg[5]);
1197
1198                 if (msg->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
1199                         cf->can_id |= CAN_RTR_FLAG;
1200                 else
1201                         memcpy(cf->data, &rx_msg[6],
1202                                cf->can_dlc);
1203         }
1204
1205         stats->rx_packets++;
1206         stats->rx_bytes += cf->can_dlc;
1207         netif_rx(skb);
1208 }
1209
1210 static void kvaser_usb_start_chip_reply(const struct kvaser_usb *dev,
1211                                         const struct kvaser_msg *msg)
1212 {
1213         struct kvaser_usb_net_priv *priv;
1214         u8 channel = msg->u.simple.channel;
1215
1216         if (channel >= dev->nchannels) {
1217                 dev_err(dev->udev->dev.parent,
1218                         "Invalid channel number (%d)\n", channel);
1219                 return;
1220         }
1221
1222         priv = dev->nets[channel];
1223
1224         if (completion_done(&priv->start_comp) &&
1225             netif_queue_stopped(priv->netdev)) {
1226                 netif_wake_queue(priv->netdev);
1227         } else {
1228                 netif_start_queue(priv->netdev);
1229                 complete(&priv->start_comp);
1230         }
1231 }
1232
1233 static void kvaser_usb_stop_chip_reply(const struct kvaser_usb *dev,
1234                                        const struct kvaser_msg *msg)
1235 {
1236         struct kvaser_usb_net_priv *priv;
1237         u8 channel = msg->u.simple.channel;
1238
1239         if (channel >= dev->nchannels) {
1240                 dev_err(dev->udev->dev.parent,
1241                         "Invalid channel number (%d)\n", channel);
1242                 return;
1243         }
1244
1245         priv = dev->nets[channel];
1246
1247         complete(&priv->stop_comp);
1248 }
1249
1250 static void kvaser_usb_handle_message(const struct kvaser_usb *dev,
1251                                       const struct kvaser_msg *msg)
1252 {
1253         switch (msg->id) {
1254         case CMD_START_CHIP_REPLY:
1255                 kvaser_usb_start_chip_reply(dev, msg);
1256                 break;
1257
1258         case CMD_STOP_CHIP_REPLY:
1259                 kvaser_usb_stop_chip_reply(dev, msg);
1260                 break;
1261
1262         case CMD_RX_STD_MESSAGE:
1263         case CMD_RX_EXT_MESSAGE:
1264                 kvaser_usb_rx_can_msg(dev, msg);
1265                 break;
1266
1267         case CMD_LEAF_LOG_MESSAGE:
1268                 if (dev->family != KVASER_LEAF)
1269                         goto warn;
1270                 kvaser_usb_rx_can_msg(dev, msg);
1271                 break;
1272
1273         case CMD_CHIP_STATE_EVENT:
1274         case CMD_CAN_ERROR_EVENT:
1275                 if (dev->family == KVASER_LEAF)
1276                         kvaser_leaf_rx_error(dev, msg);
1277                 else
1278                         kvaser_usbcan_rx_error(dev, msg);
1279                 break;
1280
1281         case CMD_TX_ACKNOWLEDGE:
1282                 kvaser_usb_tx_acknowledge(dev, msg);
1283                 break;
1284
1285         /* Ignored messages */
1286         case CMD_USBCAN_CLOCK_OVERFLOW_EVENT:
1287                 if (dev->family != KVASER_USBCAN)
1288                         goto warn;
1289                 break;
1290
1291         default:
1292 warn:           dev_warn(dev->udev->dev.parent,
1293                          "Unhandled message (%d)\n", msg->id);
1294                 break;
1295         }
1296 }
1297
1298 static void kvaser_usb_read_bulk_callback(struct urb *urb)
1299 {
1300         struct kvaser_usb *dev = urb->context;
1301         struct kvaser_msg *msg;
1302         int pos = 0;
1303         int err, i;
1304
1305         switch (urb->status) {
1306         case 0:
1307                 break;
1308         case -ENOENT:
1309         case -ESHUTDOWN:
1310                 return;
1311         default:
1312                 dev_info(dev->udev->dev.parent, "Rx URB aborted (%d)\n",
1313                          urb->status);
1314                 goto resubmit_urb;
1315         }
1316
1317         while (pos <= urb->actual_length - MSG_HEADER_LEN) {
1318                 msg = urb->transfer_buffer + pos;
1319
1320                 if (!msg->len)
1321                         break;
1322
1323                 if (pos + msg->len > urb->actual_length) {
1324                         dev_err(dev->udev->dev.parent, "Format error\n");
1325                         break;
1326                 }
1327
1328                 kvaser_usb_handle_message(dev, msg);
1329
1330                 pos += msg->len;
1331         }
1332
1333 resubmit_urb:
1334         usb_fill_bulk_urb(urb, dev->udev,
1335                           usb_rcvbulkpipe(dev->udev,
1336                                           dev->bulk_in->bEndpointAddress),
1337                           urb->transfer_buffer, RX_BUFFER_SIZE,
1338                           kvaser_usb_read_bulk_callback, dev);
1339
1340         err = usb_submit_urb(urb, GFP_ATOMIC);
1341         if (err == -ENODEV) {
1342                 for (i = 0; i < dev->nchannels; i++) {
1343                         if (!dev->nets[i])
1344                                 continue;
1345
1346                         netif_device_detach(dev->nets[i]->netdev);
1347                 }
1348         } else if (err) {
1349                 dev_err(dev->udev->dev.parent,
1350                         "Failed resubmitting read bulk urb: %d\n", err);
1351         }
1352
1353         return;
1354 }
1355
1356 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev)
1357 {
1358         int i, err = 0;
1359
1360         if (dev->rxinitdone)
1361                 return 0;
1362
1363         for (i = 0; i < MAX_RX_URBS; i++) {
1364                 struct urb *urb = NULL;
1365                 u8 *buf = NULL;
1366                 dma_addr_t buf_dma;
1367
1368                 urb = usb_alloc_urb(0, GFP_KERNEL);
1369                 if (!urb) {
1370                         dev_warn(dev->udev->dev.parent,
1371                                  "No memory left for URBs\n");
1372                         err = -ENOMEM;
1373                         break;
1374                 }
1375
1376                 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE,
1377                                          GFP_KERNEL, &buf_dma);
1378                 if (!buf) {
1379                         dev_warn(dev->udev->dev.parent,
1380                                  "No memory left for USB buffer\n");
1381                         usb_free_urb(urb);
1382                         err = -ENOMEM;
1383                         break;
1384                 }
1385
1386                 usb_fill_bulk_urb(urb, dev->udev,
1387                                   usb_rcvbulkpipe(dev->udev,
1388                                           dev->bulk_in->bEndpointAddress),
1389                                   buf, RX_BUFFER_SIZE,
1390                                   kvaser_usb_read_bulk_callback,
1391                                   dev);
1392                 urb->transfer_dma = buf_dma;
1393                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1394                 usb_anchor_urb(urb, &dev->rx_submitted);
1395
1396                 err = usb_submit_urb(urb, GFP_KERNEL);
1397                 if (err) {
1398                         usb_unanchor_urb(urb);
1399                         usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
1400                                           buf_dma);
1401                         usb_free_urb(urb);
1402                         break;
1403                 }
1404
1405                 dev->rxbuf[i] = buf;
1406                 dev->rxbuf_dma[i] = buf_dma;
1407
1408                 usb_free_urb(urb);
1409         }
1410
1411         if (i == 0) {
1412                 dev_warn(dev->udev->dev.parent,
1413                          "Cannot setup read URBs, error %d\n", err);
1414                 return err;
1415         } else if (i < MAX_RX_URBS) {
1416                 dev_warn(dev->udev->dev.parent,
1417                          "RX performances may be slow\n");
1418         }
1419
1420         dev->rxinitdone = true;
1421
1422         return 0;
1423 }
1424
1425 static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1426 {
1427         struct kvaser_msg *msg;
1428         int rc;
1429
1430         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1431         if (!msg)
1432                 return -ENOMEM;
1433
1434         msg->id = CMD_SET_CTRL_MODE;
1435         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_ctrl_mode);
1436         msg->u.ctrl_mode.tid = 0xff;
1437         msg->u.ctrl_mode.channel = priv->channel;
1438
1439         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1440                 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1441         else
1442                 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1443
1444         rc = kvaser_usb_send_msg(priv->dev, msg);
1445
1446         kfree(msg);
1447         return rc;
1448 }
1449
1450 static int kvaser_usb_start_chip(struct kvaser_usb_net_priv *priv)
1451 {
1452         int err;
1453
1454         init_completion(&priv->start_comp);
1455
1456         err = kvaser_usb_send_simple_msg(priv->dev, CMD_START_CHIP,
1457                                          priv->channel);
1458         if (err)
1459                 return err;
1460
1461         if (!wait_for_completion_timeout(&priv->start_comp,
1462                                          msecs_to_jiffies(START_TIMEOUT)))
1463                 return -ETIMEDOUT;
1464
1465         return 0;
1466 }
1467
1468 static int kvaser_usb_open(struct net_device *netdev)
1469 {
1470         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1471         struct kvaser_usb *dev = priv->dev;
1472         int err;
1473
1474         err = open_candev(netdev);
1475         if (err)
1476                 return err;
1477
1478         err = kvaser_usb_setup_rx_urbs(dev);
1479         if (err)
1480                 goto error;
1481
1482         err = kvaser_usb_set_opt_mode(priv);
1483         if (err)
1484                 goto error;
1485
1486         err = kvaser_usb_start_chip(priv);
1487         if (err) {
1488                 netdev_warn(netdev, "Cannot start device, error %d\n", err);
1489                 goto error;
1490         }
1491
1492         priv->can.state = CAN_STATE_ERROR_ACTIVE;
1493
1494         return 0;
1495
1496 error:
1497         close_candev(netdev);
1498         return err;
1499 }
1500
1501 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev)
1502 {
1503         int i;
1504
1505         usb_kill_anchored_urbs(&dev->rx_submitted);
1506
1507         for (i = 0; i < MAX_RX_URBS; i++)
1508                 usb_free_coherent(dev->udev, RX_BUFFER_SIZE,
1509                                   dev->rxbuf[i],
1510                                   dev->rxbuf_dma[i]);
1511
1512         for (i = 0; i < dev->nchannels; i++) {
1513                 struct kvaser_usb_net_priv *priv = dev->nets[i];
1514
1515                 if (priv)
1516                         kvaser_usb_unlink_tx_urbs(priv);
1517         }
1518 }
1519
1520 static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv *priv)
1521 {
1522         int err;
1523
1524         init_completion(&priv->stop_comp);
1525
1526         err = kvaser_usb_send_simple_msg(priv->dev, CMD_STOP_CHIP,
1527                                          priv->channel);
1528         if (err)
1529                 return err;
1530
1531         if (!wait_for_completion_timeout(&priv->stop_comp,
1532                                          msecs_to_jiffies(STOP_TIMEOUT)))
1533                 return -ETIMEDOUT;
1534
1535         return 0;
1536 }
1537
1538 static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv *priv)
1539 {
1540         struct kvaser_msg *msg;
1541         int rc;
1542
1543         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1544         if (!msg)
1545                 return -ENOMEM;
1546
1547         msg->id = CMD_FLUSH_QUEUE;
1548         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_flush_queue);
1549         msg->u.flush_queue.channel = priv->channel;
1550         msg->u.flush_queue.flags = 0x00;
1551
1552         rc = kvaser_usb_send_msg(priv->dev, msg);
1553
1554         kfree(msg);
1555         return rc;
1556 }
1557
1558 static int kvaser_usb_close(struct net_device *netdev)
1559 {
1560         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1561         struct kvaser_usb *dev = priv->dev;
1562         int err;
1563
1564         netif_stop_queue(netdev);
1565
1566         err = kvaser_usb_flush_queue(priv);
1567         if (err)
1568                 netdev_warn(netdev, "Cannot flush queue, error %d\n", err);
1569
1570         if (kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, priv->channel))
1571                 netdev_warn(netdev, "Cannot reset card, error %d\n", err);
1572
1573         err = kvaser_usb_stop_chip(priv);
1574         if (err)
1575                 netdev_warn(netdev, "Cannot stop device, error %d\n", err);
1576
1577         /* reset tx contexts */
1578         kvaser_usb_unlink_tx_urbs(priv);
1579
1580         priv->can.state = CAN_STATE_STOPPED;
1581         close_candev(priv->netdev);
1582
1583         return 0;
1584 }
1585
1586 static void kvaser_usb_write_bulk_callback(struct urb *urb)
1587 {
1588         struct kvaser_usb_tx_urb_context *context = urb->context;
1589         struct kvaser_usb_net_priv *priv;
1590         struct net_device *netdev;
1591
1592         if (WARN_ON(!context))
1593                 return;
1594
1595         priv = context->priv;
1596         netdev = priv->netdev;
1597
1598         kfree(urb->transfer_buffer);
1599
1600         if (!netif_device_present(netdev))
1601                 return;
1602
1603         if (urb->status)
1604                 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
1605 }
1606
1607 static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb,
1608                                          struct net_device *netdev)
1609 {
1610         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1611         struct kvaser_usb *dev = priv->dev;
1612         struct net_device_stats *stats = &netdev->stats;
1613         struct can_frame *cf = (struct can_frame *)skb->data;
1614         struct kvaser_usb_tx_urb_context *context = NULL;
1615         struct urb *urb;
1616         void *buf;
1617         struct kvaser_msg *msg;
1618         int i, err;
1619         int ret = NETDEV_TX_OK;
1620         u8 *msg_tx_can_flags = NULL;            /* GCC */
1621
1622         if (can_dropped_invalid_skb(netdev, skb))
1623                 return NETDEV_TX_OK;
1624
1625         urb = usb_alloc_urb(0, GFP_ATOMIC);
1626         if (!urb) {
1627                 netdev_err(netdev, "No memory left for URBs\n");
1628                 stats->tx_dropped++;
1629                 dev_kfree_skb(skb);
1630                 return NETDEV_TX_OK;
1631         }
1632
1633         buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
1634         if (!buf) {
1635                 stats->tx_dropped++;
1636                 dev_kfree_skb(skb);
1637                 goto nobufmem;
1638         }
1639
1640         msg = buf;
1641         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_tx_can);
1642         msg->u.tx_can.channel = priv->channel;
1643
1644         switch (dev->family) {
1645         case KVASER_LEAF:
1646                 msg_tx_can_flags = &msg->u.tx_can.leaf.flags;
1647                 break;
1648         case KVASER_USBCAN:
1649                 msg_tx_can_flags = &msg->u.tx_can.usbcan.flags;
1650                 break;
1651         }
1652
1653         *msg_tx_can_flags = 0;
1654
1655         if (cf->can_id & CAN_EFF_FLAG) {
1656                 msg->id = CMD_TX_EXT_MESSAGE;
1657                 msg->u.tx_can.msg[0] = (cf->can_id >> 24) & 0x1f;
1658                 msg->u.tx_can.msg[1] = (cf->can_id >> 18) & 0x3f;
1659                 msg->u.tx_can.msg[2] = (cf->can_id >> 14) & 0x0f;
1660                 msg->u.tx_can.msg[3] = (cf->can_id >> 6) & 0xff;
1661                 msg->u.tx_can.msg[4] = cf->can_id & 0x3f;
1662         } else {
1663                 msg->id = CMD_TX_STD_MESSAGE;
1664                 msg->u.tx_can.msg[0] = (cf->can_id >> 6) & 0x1f;
1665                 msg->u.tx_can.msg[1] = cf->can_id & 0x3f;
1666         }
1667
1668         msg->u.tx_can.msg[5] = cf->can_dlc;
1669         memcpy(&msg->u.tx_can.msg[6], cf->data, cf->can_dlc);
1670
1671         if (cf->can_id & CAN_RTR_FLAG)
1672                 *msg_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
1673
1674         for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++) {
1675                 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
1676                         context = &priv->tx_contexts[i];
1677                         break;
1678                 }
1679         }
1680
1681         /* This should never happen; it implies a flow control bug */
1682         if (!context) {
1683                 netdev_warn(netdev, "cannot find free context\n");
1684                 ret =  NETDEV_TX_BUSY;
1685                 goto releasebuf;
1686         }
1687
1688         context->priv = priv;
1689         context->echo_index = i;
1690         context->dlc = cf->can_dlc;
1691
1692         msg->u.tx_can.tid = context->echo_index;
1693
1694         usb_fill_bulk_urb(urb, dev->udev,
1695                           usb_sndbulkpipe(dev->udev,
1696                                           dev->bulk_out->bEndpointAddress),
1697                           buf, msg->len,
1698                           kvaser_usb_write_bulk_callback, context);
1699         usb_anchor_urb(urb, &priv->tx_submitted);
1700
1701         can_put_echo_skb(skb, netdev, context->echo_index);
1702
1703         atomic_inc(&priv->active_tx_urbs);
1704
1705         if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
1706                 netif_stop_queue(netdev);
1707
1708         err = usb_submit_urb(urb, GFP_ATOMIC);
1709         if (unlikely(err)) {
1710                 can_free_echo_skb(netdev, context->echo_index);
1711
1712                 atomic_dec(&priv->active_tx_urbs);
1713                 usb_unanchor_urb(urb);
1714
1715                 stats->tx_dropped++;
1716
1717                 if (err == -ENODEV)
1718                         netif_device_detach(netdev);
1719                 else
1720                         netdev_warn(netdev, "Failed tx_urb %d\n", err);
1721
1722                 goto releasebuf;
1723         }
1724
1725         usb_free_urb(urb);
1726
1727         return NETDEV_TX_OK;
1728
1729 releasebuf:
1730         kfree(buf);
1731 nobufmem:
1732         usb_free_urb(urb);
1733         return ret;
1734 }
1735
1736 static const struct net_device_ops kvaser_usb_netdev_ops = {
1737         .ndo_open = kvaser_usb_open,
1738         .ndo_stop = kvaser_usb_close,
1739         .ndo_start_xmit = kvaser_usb_start_xmit,
1740         .ndo_change_mtu = can_change_mtu,
1741 };
1742
1743 static const struct can_bittiming_const kvaser_usb_bittiming_const = {
1744         .name = "kvaser_usb",
1745         .tseg1_min = KVASER_USB_TSEG1_MIN,
1746         .tseg1_max = KVASER_USB_TSEG1_MAX,
1747         .tseg2_min = KVASER_USB_TSEG2_MIN,
1748         .tseg2_max = KVASER_USB_TSEG2_MAX,
1749         .sjw_max = KVASER_USB_SJW_MAX,
1750         .brp_min = KVASER_USB_BRP_MIN,
1751         .brp_max = KVASER_USB_BRP_MAX,
1752         .brp_inc = KVASER_USB_BRP_INC,
1753 };
1754
1755 static int kvaser_usb_set_bittiming(struct net_device *netdev)
1756 {
1757         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1758         struct can_bittiming *bt = &priv->can.bittiming;
1759         struct kvaser_usb *dev = priv->dev;
1760         struct kvaser_msg *msg;
1761         int rc;
1762
1763         msg = kmalloc(sizeof(*msg), GFP_KERNEL);
1764         if (!msg)
1765                 return -ENOMEM;
1766
1767         msg->id = CMD_SET_BUS_PARAMS;
1768         msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_busparams);
1769         msg->u.busparams.channel = priv->channel;
1770         msg->u.busparams.tid = 0xff;
1771         msg->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
1772         msg->u.busparams.sjw = bt->sjw;
1773         msg->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
1774         msg->u.busparams.tseg2 = bt->phase_seg2;
1775
1776         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1777                 msg->u.busparams.no_samp = 3;
1778         else
1779                 msg->u.busparams.no_samp = 1;
1780
1781         rc = kvaser_usb_send_msg(dev, msg);
1782
1783         kfree(msg);
1784         return rc;
1785 }
1786
1787 static int kvaser_usb_set_mode(struct net_device *netdev,
1788                                enum can_mode mode)
1789 {
1790         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1791         int err;
1792
1793         switch (mode) {
1794         case CAN_MODE_START:
1795                 err = kvaser_usb_simple_msg_async(priv, CMD_START_CHIP);
1796                 if (err)
1797                         return err;
1798                 break;
1799         default:
1800                 return -EOPNOTSUPP;
1801         }
1802
1803         return 0;
1804 }
1805
1806 static int kvaser_usb_get_berr_counter(const struct net_device *netdev,
1807                                        struct can_berr_counter *bec)
1808 {
1809         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1810
1811         *bec = priv->bec;
1812
1813         return 0;
1814 }
1815
1816 static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev)
1817 {
1818         int i;
1819
1820         for (i = 0; i < dev->nchannels; i++) {
1821                 if (!dev->nets[i])
1822                         continue;
1823
1824                 unregister_netdev(dev->nets[i]->netdev);
1825         }
1826
1827         kvaser_usb_unlink_all_urbs(dev);
1828
1829         for (i = 0; i < dev->nchannels; i++) {
1830                 if (!dev->nets[i])
1831                         continue;
1832
1833                 free_candev(dev->nets[i]->netdev);
1834         }
1835 }
1836
1837 static int kvaser_usb_init_one(struct usb_interface *intf,
1838                                const struct usb_device_id *id, int channel)
1839 {
1840         struct kvaser_usb *dev = usb_get_intfdata(intf);
1841         struct net_device *netdev;
1842         struct kvaser_usb_net_priv *priv;
1843         int i, err;
1844
1845         err = kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, channel);
1846         if (err)
1847                 return err;
1848
1849         netdev = alloc_candev(sizeof(*priv), MAX_TX_URBS);
1850         if (!netdev) {
1851                 dev_err(&intf->dev, "Cannot alloc candev\n");
1852                 return -ENOMEM;
1853         }
1854
1855         priv = netdev_priv(netdev);
1856
1857         init_completion(&priv->start_comp);
1858         init_completion(&priv->stop_comp);
1859
1860         init_usb_anchor(&priv->tx_submitted);
1861         atomic_set(&priv->active_tx_urbs, 0);
1862
1863         for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++)
1864                 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
1865
1866         priv->dev = dev;
1867         priv->netdev = netdev;
1868         priv->channel = channel;
1869
1870         priv->can.state = CAN_STATE_STOPPED;
1871         priv->can.clock.freq = CAN_USB_CLOCK;
1872         priv->can.bittiming_const = &kvaser_usb_bittiming_const;
1873         priv->can.do_set_bittiming = kvaser_usb_set_bittiming;
1874         priv->can.do_set_mode = kvaser_usb_set_mode;
1875         if (id->driver_info & KVASER_HAS_TXRX_ERRORS)
1876                 priv->can.do_get_berr_counter = kvaser_usb_get_berr_counter;
1877         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
1878         if (id->driver_info & KVASER_HAS_SILENT_MODE)
1879                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
1880
1881         netdev->flags |= IFF_ECHO;
1882
1883         netdev->netdev_ops = &kvaser_usb_netdev_ops;
1884
1885         SET_NETDEV_DEV(netdev, &intf->dev);
1886         netdev->dev_id = channel;
1887
1888         dev->nets[channel] = priv;
1889
1890         err = register_candev(netdev);
1891         if (err) {
1892                 dev_err(&intf->dev, "Failed to register can device\n");
1893                 free_candev(netdev);
1894                 dev->nets[channel] = NULL;
1895                 return err;
1896         }
1897
1898         netdev_dbg(netdev, "device registered\n");
1899
1900         return 0;
1901 }
1902
1903 static int kvaser_usb_get_endpoints(const struct usb_interface *intf,
1904                                     struct usb_endpoint_descriptor **in,
1905                                     struct usb_endpoint_descriptor **out)
1906 {
1907         const struct usb_host_interface *iface_desc;
1908         struct usb_endpoint_descriptor *endpoint;
1909         int i;
1910
1911         iface_desc = &intf->altsetting[0];
1912
1913         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1914                 endpoint = &iface_desc->endpoint[i].desc;
1915
1916                 if (!*in && usb_endpoint_is_bulk_in(endpoint))
1917                         *in = endpoint;
1918
1919                 if (!*out && usb_endpoint_is_bulk_out(endpoint))
1920                         *out = endpoint;
1921
1922                 /* use first bulk endpoint for in and out */
1923                 if (*in && *out)
1924                         return 0;
1925         }
1926
1927         return -ENODEV;
1928 }
1929
1930 static int kvaser_usb_probe(struct usb_interface *intf,
1931                             const struct usb_device_id *id)
1932 {
1933         struct kvaser_usb *dev;
1934         int err = -ENOMEM;
1935         int i, retry = 3;
1936
1937         dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL);
1938         if (!dev)
1939                 return -ENOMEM;
1940
1941         if (kvaser_is_leaf(id)) {
1942                 dev->family = KVASER_LEAF;
1943         } else if (kvaser_is_usbcan(id)) {
1944                 dev->family = KVASER_USBCAN;
1945         } else {
1946                 dev_err(&intf->dev,
1947                         "Product ID (%d) does not belong to any known Kvaser USB family",
1948                         id->idProduct);
1949                 return -ENODEV;
1950         }
1951
1952         err = kvaser_usb_get_endpoints(intf, &dev->bulk_in, &dev->bulk_out);
1953         if (err) {
1954                 dev_err(&intf->dev, "Cannot get usb endpoint(s)");
1955                 return err;
1956         }
1957
1958         dev->udev = interface_to_usbdev(intf);
1959
1960         init_usb_anchor(&dev->rx_submitted);
1961
1962         usb_set_intfdata(intf, dev);
1963
1964         /* On some x86 laptops, plugging a Kvaser device again after
1965          * an unplug makes the firmware always ignore the very first
1966          * command. For such a case, provide some room for retries
1967          * instead of completely exiting the driver.
1968          */
1969         do {
1970                 err = kvaser_usb_get_software_info(dev);
1971         } while (--retry && err == -ETIMEDOUT);
1972
1973         if (err) {
1974                 dev_err(&intf->dev,
1975                         "Cannot get software infos, error %d\n", err);
1976                 return err;
1977         }
1978
1979         err = kvaser_usb_get_card_info(dev);
1980         if (err) {
1981                 dev_err(&intf->dev,
1982                         "Cannot get card infos, error %d\n", err);
1983                 return err;
1984         }
1985
1986         dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n",
1987                 ((dev->fw_version >> 24) & 0xff),
1988                 ((dev->fw_version >> 16) & 0xff),
1989                 (dev->fw_version & 0xffff));
1990
1991         for (i = 0; i < dev->nchannels; i++) {
1992                 err = kvaser_usb_init_one(intf, id, i);
1993                 if (err) {
1994                         kvaser_usb_remove_interfaces(dev);
1995                         return err;
1996                 }
1997         }
1998
1999         return 0;
2000 }
2001
2002 static void kvaser_usb_disconnect(struct usb_interface *intf)
2003 {
2004         struct kvaser_usb *dev = usb_get_intfdata(intf);
2005
2006         usb_set_intfdata(intf, NULL);
2007
2008         if (!dev)
2009                 return;
2010
2011         kvaser_usb_remove_interfaces(dev);
2012 }
2013
2014 static struct usb_driver kvaser_usb_driver = {
2015         .name = "kvaser_usb",
2016         .probe = kvaser_usb_probe,
2017         .disconnect = kvaser_usb_disconnect,
2018         .id_table = kvaser_usb_table,
2019 };
2020
2021 module_usb_driver(kvaser_usb_driver);
2022
2023 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
2024 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
2025 MODULE_LICENSE("GPL v2");