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