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