linux/drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/* Parts of this driver are based on the following:
   3 *  - Kvaser linux leaf driver (version 4.78)
   4 *  - CAN driver for esd CAN-USB/2
   5 *  - Kvaser linux usbcanII driver (version 5.3)
   6 *
   7 * Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved.
   8 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
   9 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
  10 * Copyright (C) 2015 Valeo S.A.
  11 */
  12
  13#include <linux/completion.h>
  14#include <linux/device.h>
  15#include <linux/gfp.h>
  16#include <linux/jiffies.h>
  17#include <linux/kernel.h>
  18#include <linux/netdevice.h>
  19#include <linux/spinlock.h>
  20#include <linux/string.h>
  21#include <linux/types.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#include <linux/can/netlink.h>
  28
  29#include "kvaser_usb.h"
  30
  31/* Forward declaration */
  32static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg;
  33
  34#define CAN_USB_CLOCK                   8000000
  35#define MAX_USBCAN_NET_DEVICES          2
  36
  37/* Command header size */
  38#define CMD_HEADER_LEN                  2
  39
  40/* Kvaser CAN message flags */
  41#define MSG_FLAG_ERROR_FRAME            BIT(0)
  42#define MSG_FLAG_OVERRUN                BIT(1)
  43#define MSG_FLAG_NERR                   BIT(2)
  44#define MSG_FLAG_WAKEUP                 BIT(3)
  45#define MSG_FLAG_REMOTE_FRAME           BIT(4)
  46#define MSG_FLAG_RESERVED               BIT(5)
  47#define MSG_FLAG_TX_ACK                 BIT(6)
  48#define MSG_FLAG_TX_REQUEST             BIT(7)
  49
  50/* CAN states (M16C CxSTRH register) */
  51#define M16C_STATE_BUS_RESET            BIT(0)
  52#define M16C_STATE_BUS_ERROR            BIT(4)
  53#define M16C_STATE_BUS_PASSIVE          BIT(5)
  54#define M16C_STATE_BUS_OFF              BIT(6)
  55
  56/* Leaf/usbcan command ids */
  57#define CMD_RX_STD_MESSAGE              12
  58#define CMD_TX_STD_MESSAGE              13
  59#define CMD_RX_EXT_MESSAGE              14
  60#define CMD_TX_EXT_MESSAGE              15
  61#define CMD_SET_BUS_PARAMS              16
  62#define CMD_CHIP_STATE_EVENT            20
  63#define CMD_SET_CTRL_MODE               21
  64#define CMD_RESET_CHIP                  24
  65#define CMD_START_CHIP                  26
  66#define CMD_START_CHIP_REPLY            27
  67#define CMD_STOP_CHIP                   28
  68#define CMD_STOP_CHIP_REPLY             29
  69
  70#define CMD_USBCAN_CLOCK_OVERFLOW_EVENT 33
  71
  72#define CMD_GET_CARD_INFO               34
  73#define CMD_GET_CARD_INFO_REPLY         35
  74#define CMD_GET_SOFTWARE_INFO           38
  75#define CMD_GET_SOFTWARE_INFO_REPLY     39
  76#define CMD_FLUSH_QUEUE                 48
  77#define CMD_TX_ACKNOWLEDGE              50
  78#define CMD_CAN_ERROR_EVENT             51
  79#define CMD_FLUSH_QUEUE_REPLY           68
  80
  81#define CMD_LEAF_LOG_MESSAGE            106
  82
  83/* error factors */
  84#define M16C_EF_ACKE                    BIT(0)
  85#define M16C_EF_CRCE                    BIT(1)
  86#define M16C_EF_FORME                   BIT(2)
  87#define M16C_EF_STFE                    BIT(3)
  88#define M16C_EF_BITE0                   BIT(4)
  89#define M16C_EF_BITE1                   BIT(5)
  90#define M16C_EF_RCVE                    BIT(6)
  91#define M16C_EF_TRE                     BIT(7)
  92
  93/* Only Leaf-based devices can report M16C error factors,
  94 * thus define our own error status flags for USBCANII
  95 */
  96#define USBCAN_ERROR_STATE_NONE         0
  97#define USBCAN_ERROR_STATE_TX_ERROR     BIT(0)
  98#define USBCAN_ERROR_STATE_RX_ERROR     BIT(1)
  99#define USBCAN_ERROR_STATE_BUSERROR     BIT(2)
 100
 101/* bittiming parameters */
 102#define KVASER_USB_TSEG1_MIN            1
 103#define KVASER_USB_TSEG1_MAX            16
 104#define KVASER_USB_TSEG2_MIN            1
 105#define KVASER_USB_TSEG2_MAX            8
 106#define KVASER_USB_SJW_MAX              4
 107#define KVASER_USB_BRP_MIN              1
 108#define KVASER_USB_BRP_MAX              64
 109#define KVASER_USB_BRP_INC              1
 110
 111/* ctrl modes */
 112#define KVASER_CTRL_MODE_NORMAL         1
 113#define KVASER_CTRL_MODE_SILENT         2
 114#define KVASER_CTRL_MODE_SELFRECEPTION  3
 115#define KVASER_CTRL_MODE_OFF            4
 116
 117/* Extended CAN identifier flag */
 118#define KVASER_EXTENDED_FRAME           BIT(31)
 119
 120struct kvaser_cmd_simple {
 121        u8 tid;
 122        u8 channel;
 123} __packed;
 124
 125struct kvaser_cmd_cardinfo {
 126        u8 tid;
 127        u8 nchannels;
 128        __le32 serial_number;
 129        __le32 padding0;
 130        __le32 clock_resolution;
 131        __le32 mfgdate;
 132        u8 ean[8];
 133        u8 hw_revision;
 134        union {
 135                struct {
 136                        u8 usb_hs_mode;
 137                } __packed leaf1;
 138                struct {
 139                        u8 padding;
 140                } __packed usbcan1;
 141        } __packed;
 142        __le16 padding1;
 143} __packed;
 144
 145struct leaf_cmd_softinfo {
 146        u8 tid;
 147        u8 padding0;
 148        __le32 sw_options;
 149        __le32 fw_version;
 150        __le16 max_outstanding_tx;
 151        __le16 padding1[9];
 152} __packed;
 153
 154struct usbcan_cmd_softinfo {
 155        u8 tid;
 156        u8 fw_name[5];
 157        __le16 max_outstanding_tx;
 158        u8 padding[6];
 159        __le32 fw_version;
 160        __le16 checksum;
 161        __le16 sw_options;
 162} __packed;
 163
 164struct kvaser_cmd_busparams {
 165        u8 tid;
 166        u8 channel;
 167        __le32 bitrate;
 168        u8 tseg1;
 169        u8 tseg2;
 170        u8 sjw;
 171        u8 no_samp;
 172} __packed;
 173
 174struct kvaser_cmd_tx_can {
 175        u8 channel;
 176        u8 tid;
 177        u8 data[14];
 178        union {
 179                struct {
 180                        u8 padding;
 181                        u8 flags;
 182                } __packed leaf;
 183                struct {
 184                        u8 flags;
 185                        u8 padding;
 186                } __packed usbcan;
 187        } __packed;
 188} __packed;
 189
 190struct kvaser_cmd_rx_can_header {
 191        u8 channel;
 192        u8 flag;
 193} __packed;
 194
 195struct leaf_cmd_rx_can {
 196        u8 channel;
 197        u8 flag;
 198
 199        __le16 time[3];
 200        u8 data[14];
 201} __packed;
 202
 203struct usbcan_cmd_rx_can {
 204        u8 channel;
 205        u8 flag;
 206
 207        u8 data[14];
 208        __le16 time;
 209} __packed;
 210
 211struct leaf_cmd_chip_state_event {
 212        u8 tid;
 213        u8 channel;
 214
 215        __le16 time[3];
 216        u8 tx_errors_count;
 217        u8 rx_errors_count;
 218
 219        u8 status;
 220        u8 padding[3];
 221} __packed;
 222
 223struct usbcan_cmd_chip_state_event {
 224        u8 tid;
 225        u8 channel;
 226
 227        u8 tx_errors_count;
 228        u8 rx_errors_count;
 229        __le16 time;
 230
 231        u8 status;
 232        u8 padding[3];
 233} __packed;
 234
 235struct kvaser_cmd_tx_acknowledge_header {
 236        u8 channel;
 237        u8 tid;
 238} __packed;
 239
 240struct leaf_cmd_error_event {
 241        u8 tid;
 242        u8 flags;
 243        __le16 time[3];
 244        u8 channel;
 245        u8 padding;
 246        u8 tx_errors_count;
 247        u8 rx_errors_count;
 248        u8 status;
 249        u8 error_factor;
 250} __packed;
 251
 252struct usbcan_cmd_error_event {
 253        u8 tid;
 254        u8 padding;
 255        u8 tx_errors_count_ch0;
 256        u8 rx_errors_count_ch0;
 257        u8 tx_errors_count_ch1;
 258        u8 rx_errors_count_ch1;
 259        u8 status_ch0;
 260        u8 status_ch1;
 261        __le16 time;
 262} __packed;
 263
 264struct kvaser_cmd_ctrl_mode {
 265        u8 tid;
 266        u8 channel;
 267        u8 ctrl_mode;
 268        u8 padding[3];
 269} __packed;
 270
 271struct kvaser_cmd_flush_queue {
 272        u8 tid;
 273        u8 channel;
 274        u8 flags;
 275        u8 padding[3];
 276} __packed;
 277
 278struct leaf_cmd_log_message {
 279        u8 channel;
 280        u8 flags;
 281        __le16 time[3];
 282        u8 dlc;
 283        u8 time_offset;
 284        __le32 id;
 285        u8 data[8];
 286} __packed;
 287
 288struct kvaser_cmd {
 289        u8 len;
 290        u8 id;
 291        union   {
 292                struct kvaser_cmd_simple simple;
 293                struct kvaser_cmd_cardinfo cardinfo;
 294                struct kvaser_cmd_busparams busparams;
 295
 296                struct kvaser_cmd_rx_can_header rx_can_header;
 297                struct kvaser_cmd_tx_acknowledge_header tx_acknowledge_header;
 298
 299                union {
 300                        struct leaf_cmd_softinfo softinfo;
 301                        struct leaf_cmd_rx_can rx_can;
 302                        struct leaf_cmd_chip_state_event chip_state_event;
 303                        struct leaf_cmd_error_event error_event;
 304                        struct leaf_cmd_log_message log_message;
 305                } __packed leaf;
 306
 307                union {
 308                        struct usbcan_cmd_softinfo softinfo;
 309                        struct usbcan_cmd_rx_can rx_can;
 310                        struct usbcan_cmd_chip_state_event chip_state_event;
 311                        struct usbcan_cmd_error_event error_event;
 312                } __packed usbcan;
 313
 314                struct kvaser_cmd_tx_can tx_can;
 315                struct kvaser_cmd_ctrl_mode ctrl_mode;
 316                struct kvaser_cmd_flush_queue flush_queue;
 317        } u;
 318} __packed;
 319
 320/* Summary of a kvaser error event, for a unified Leaf/Usbcan error
 321 * handling. Some discrepancies between the two families exist:
 322 *
 323 * - USBCAN firmware does not report M16C "error factors"
 324 * - USBCAN controllers has difficulties reporting if the raised error
 325 *   event is for ch0 or ch1. They leave such arbitration to the OS
 326 *   driver by letting it compare error counters with previous values
 327 *   and decide the error event's channel. Thus for USBCAN, the channel
 328 *   field is only advisory.
 329 */
 330struct kvaser_usb_err_summary {
 331        u8 channel, status, txerr, rxerr;
 332        union {
 333                struct {
 334                        u8 error_factor;
 335                } leaf;
 336                struct {
 337                        u8 other_ch_status;
 338                        u8 error_state;
 339                } usbcan;
 340        };
 341};
 342
 343static void *
 344kvaser_usb_leaf_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
 345                             const struct sk_buff *skb, int *frame_len,
 346                             int *cmd_len, u16 transid)
 347{
 348        struct kvaser_usb *dev = priv->dev;
 349        struct kvaser_cmd *cmd;
 350        u8 *cmd_tx_can_flags = NULL;            /* GCC */
 351        struct can_frame *cf = (struct can_frame *)skb->data;
 352
 353        *frame_len = cf->can_dlc;
 354
 355        cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
 356        if (cmd) {
 357                cmd->u.tx_can.tid = transid & 0xff;
 358                cmd->len = *cmd_len = CMD_HEADER_LEN +
 359                                      sizeof(struct kvaser_cmd_tx_can);
 360                cmd->u.tx_can.channel = priv->channel;
 361
 362                switch (dev->card_data.leaf.family) {
 363                case KVASER_LEAF:
 364                        cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags;
 365                        break;
 366                case KVASER_USBCAN:
 367                        cmd_tx_can_flags = &cmd->u.tx_can.usbcan.flags;
 368                        break;
 369                }
 370
 371                *cmd_tx_can_flags = 0;
 372
 373                if (cf->can_id & CAN_EFF_FLAG) {
 374                        cmd->id = CMD_TX_EXT_MESSAGE;
 375                        cmd->u.tx_can.data[0] = (cf->can_id >> 24) & 0x1f;
 376                        cmd->u.tx_can.data[1] = (cf->can_id >> 18) & 0x3f;
 377                        cmd->u.tx_can.data[2] = (cf->can_id >> 14) & 0x0f;
 378                        cmd->u.tx_can.data[3] = (cf->can_id >> 6) & 0xff;
 379                        cmd->u.tx_can.data[4] = cf->can_id & 0x3f;
 380                } else {
 381                        cmd->id = CMD_TX_STD_MESSAGE;
 382                        cmd->u.tx_can.data[0] = (cf->can_id >> 6) & 0x1f;
 383                        cmd->u.tx_can.data[1] = cf->can_id & 0x3f;
 384                }
 385
 386                cmd->u.tx_can.data[5] = cf->can_dlc;
 387                memcpy(&cmd->u.tx_can.data[6], cf->data, cf->can_dlc);
 388
 389                if (cf->can_id & CAN_RTR_FLAG)
 390                        *cmd_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
 391        }
 392        return cmd;
 393}
 394
 395static int kvaser_usb_leaf_wait_cmd(const struct kvaser_usb *dev, u8 id,
 396                                    struct kvaser_cmd *cmd)
 397{
 398        struct kvaser_cmd *tmp;
 399        void *buf;
 400        int actual_len;
 401        int err;
 402        int pos;
 403        unsigned long to = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT);
 404
 405        buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL);
 406        if (!buf)
 407                return -ENOMEM;
 408
 409        do {
 410                err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE,
 411                                          &actual_len);
 412                if (err < 0)
 413                        goto end;
 414
 415                pos = 0;
 416                while (pos <= actual_len - CMD_HEADER_LEN) {
 417                        tmp = buf + pos;
 418
 419                        /* Handle commands crossing the USB endpoint max packet
 420                         * size boundary. Check kvaser_usb_read_bulk_callback()
 421                         * for further details.
 422                         */
 423                        if (tmp->len == 0) {
 424                                pos = round_up(pos,
 425                                               le16_to_cpu
 426                                                (dev->bulk_in->wMaxPacketSize));
 427                                continue;
 428                        }
 429
 430                        if (pos + tmp->len > actual_len) {
 431                                dev_err_ratelimited(&dev->intf->dev,
 432                                                    "Format error\n");
 433                                break;
 434                        }
 435
 436                        if (tmp->id == id) {
 437                                memcpy(cmd, tmp, tmp->len);
 438                                goto end;
 439                        }
 440
 441                        pos += tmp->len;
 442                }
 443        } while (time_before(jiffies, to));
 444
 445        err = -EINVAL;
 446
 447end:
 448        kfree(buf);
 449
 450        return err;
 451}
 452
 453static int kvaser_usb_leaf_send_simple_cmd(const struct kvaser_usb *dev,
 454                                           u8 cmd_id, int channel)
 455{
 456        struct kvaser_cmd *cmd;
 457        int rc;
 458
 459        cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
 460        if (!cmd)
 461                return -ENOMEM;
 462
 463        cmd->id = cmd_id;
 464        cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
 465        cmd->u.simple.channel = channel;
 466        cmd->u.simple.tid = 0xff;
 467
 468        rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
 469
 470        kfree(cmd);
 471        return rc;
 472}
 473
 474static int kvaser_usb_leaf_get_software_info_inner(struct kvaser_usb *dev)
 475{
 476        struct kvaser_cmd cmd;
 477        int err;
 478
 479        err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO, 0);
 480        if (err)
 481                return err;
 482
 483        err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_REPLY, &cmd);
 484        if (err)
 485                return err;
 486
 487        switch (dev->card_data.leaf.family) {
 488        case KVASER_LEAF:
 489                dev->fw_version = le32_to_cpu(cmd.u.leaf.softinfo.fw_version);
 490                dev->max_tx_urbs =
 491                        le16_to_cpu(cmd.u.leaf.softinfo.max_outstanding_tx);
 492                break;
 493        case KVASER_USBCAN:
 494                dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version);
 495                dev->max_tx_urbs =
 496                        le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx);
 497                break;
 498        }
 499
 500        return 0;
 501}
 502
 503static int kvaser_usb_leaf_get_software_info(struct kvaser_usb *dev)
 504{
 505        int err;
 506        int retry = 3;
 507
 508        /* On some x86 laptops, plugging a Kvaser device again after
 509         * an unplug makes the firmware always ignore the very first
 510         * command. For such a case, provide some room for retries
 511         * instead of completely exiting the driver.
 512         */
 513        do {
 514                err = kvaser_usb_leaf_get_software_info_inner(dev);
 515        } while (--retry && err == -ETIMEDOUT);
 516
 517        return err;
 518}
 519
 520static int kvaser_usb_leaf_get_card_info(struct kvaser_usb *dev)
 521{
 522        struct kvaser_cmd cmd;
 523        int err;
 524
 525        err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_CARD_INFO, 0);
 526        if (err)
 527                return err;
 528
 529        err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_CARD_INFO_REPLY, &cmd);
 530        if (err)
 531                return err;
 532
 533        dev->nchannels = cmd.u.cardinfo.nchannels;
 534        if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES ||
 535            (dev->card_data.leaf.family == KVASER_USBCAN &&
 536             dev->nchannels > MAX_USBCAN_NET_DEVICES))
 537                return -EINVAL;
 538
 539        return 0;
 540}
 541
 542static void kvaser_usb_leaf_tx_acknowledge(const struct kvaser_usb *dev,
 543                                           const struct kvaser_cmd *cmd)
 544{
 545        struct net_device_stats *stats;
 546        struct kvaser_usb_tx_urb_context *context;
 547        struct kvaser_usb_net_priv *priv;
 548        unsigned long flags;
 549        u8 channel, tid;
 550
 551        channel = cmd->u.tx_acknowledge_header.channel;
 552        tid = cmd->u.tx_acknowledge_header.tid;
 553
 554        if (channel >= dev->nchannels) {
 555                dev_err(&dev->intf->dev,
 556                        "Invalid channel number (%d)\n", channel);
 557                return;
 558        }
 559
 560        priv = dev->nets[channel];
 561
 562        if (!netif_device_present(priv->netdev))
 563                return;
 564
 565        stats = &priv->netdev->stats;
 566
 567        context = &priv->tx_contexts[tid % dev->max_tx_urbs];
 568
 569        /* Sometimes the state change doesn't come after a bus-off event */
 570        if (priv->can.restart_ms && priv->can.state >= CAN_STATE_BUS_OFF) {
 571                struct sk_buff *skb;
 572                struct can_frame *cf;
 573
 574                skb = alloc_can_err_skb(priv->netdev, &cf);
 575                if (skb) {
 576                        cf->can_id |= CAN_ERR_RESTARTED;
 577
 578                        stats->rx_packets++;
 579                        stats->rx_bytes += cf->can_dlc;
 580                        netif_rx(skb);
 581                } else {
 582                        netdev_err(priv->netdev,
 583                                   "No memory left for err_skb\n");
 584                }
 585
 586                priv->can.can_stats.restarts++;
 587                netif_carrier_on(priv->netdev);
 588
 589                priv->can.state = CAN_STATE_ERROR_ACTIVE;
 590        }
 591
 592        stats->tx_packets++;
 593        stats->tx_bytes += context->dlc;
 594
 595        spin_lock_irqsave(&priv->tx_contexts_lock, flags);
 596
 597        can_get_echo_skb(priv->netdev, context->echo_index);
 598        context->echo_index = dev->max_tx_urbs;
 599        --priv->active_tx_contexts;
 600        netif_wake_queue(priv->netdev);
 601
 602        spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
 603}
 604
 605static int kvaser_usb_leaf_simple_cmd_async(struct kvaser_usb_net_priv *priv,
 606                                            u8 cmd_id)
 607{
 608        struct kvaser_cmd *cmd;
 609        int err;
 610
 611        cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
 612        if (!cmd)
 613                return -ENOMEM;
 614
 615        cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
 616        cmd->id = cmd_id;
 617        cmd->u.simple.channel = priv->channel;
 618
 619        err = kvaser_usb_send_cmd_async(priv, cmd, cmd->len);
 620        if (err)
 621                kfree(cmd);
 622
 623        return err;
 624}
 625
 626static void
 627kvaser_usb_leaf_rx_error_update_can_state(struct kvaser_usb_net_priv *priv,
 628                                        const struct kvaser_usb_err_summary *es,
 629                                        struct can_frame *cf)
 630{
 631        struct kvaser_usb *dev = priv->dev;
 632        struct net_device_stats *stats = &priv->netdev->stats;
 633        enum can_state cur_state, new_state, tx_state, rx_state;
 634
 635        netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status);
 636
 637        new_state = priv->can.state;
 638        cur_state = priv->can.state;
 639
 640        if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
 641                new_state = CAN_STATE_BUS_OFF;
 642        } else if (es->status & M16C_STATE_BUS_PASSIVE) {
 643                new_state = CAN_STATE_ERROR_PASSIVE;
 644        } else if (es->status & M16C_STATE_BUS_ERROR) {
 645                /* Guard against spurious error events after a busoff */
 646                if (cur_state < CAN_STATE_BUS_OFF) {
 647                        if (es->txerr >= 128 || es->rxerr >= 128)
 648                                new_state = CAN_STATE_ERROR_PASSIVE;
 649                        else if (es->txerr >= 96 || es->rxerr >= 96)
 650                                new_state = CAN_STATE_ERROR_WARNING;
 651                        else if (cur_state > CAN_STATE_ERROR_ACTIVE)
 652                                new_state = CAN_STATE_ERROR_ACTIVE;
 653                }
 654        }
 655
 656        if (!es->status)
 657                new_state = CAN_STATE_ERROR_ACTIVE;
 658
 659        if (new_state != cur_state) {
 660                tx_state = (es->txerr >= es->rxerr) ? new_state : 0;
 661                rx_state = (es->txerr <= es->rxerr) ? new_state : 0;
 662
 663                can_change_state(priv->netdev, cf, tx_state, rx_state);
 664        }
 665
 666        if (priv->can.restart_ms &&
 667            cur_state >= CAN_STATE_BUS_OFF &&
 668            new_state < CAN_STATE_BUS_OFF)
 669                priv->can.can_stats.restarts++;
 670
 671        switch (dev->card_data.leaf.family) {
 672        case KVASER_LEAF:
 673                if (es->leaf.error_factor) {
 674                        priv->can.can_stats.bus_error++;
 675                        stats->rx_errors++;
 676                }
 677                break;
 678        case KVASER_USBCAN:
 679                if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR)
 680                        stats->tx_errors++;
 681                if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR)
 682                        stats->rx_errors++;
 683                if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
 684                        priv->can.can_stats.bus_error++;
 685                break;
 686        }
 687
 688        priv->bec.txerr = es->txerr;
 689        priv->bec.rxerr = es->rxerr;
 690}
 691
 692static void kvaser_usb_leaf_rx_error(const struct kvaser_usb *dev,
 693                                     const struct kvaser_usb_err_summary *es)
 694{
 695        struct can_frame *cf;
 696        struct can_frame tmp_cf = { .can_id = CAN_ERR_FLAG,
 697                                    .can_dlc = CAN_ERR_DLC };
 698        struct sk_buff *skb;
 699        struct net_device_stats *stats;
 700        struct kvaser_usb_net_priv *priv;
 701        enum can_state old_state, new_state;
 702
 703        if (es->channel >= dev->nchannels) {
 704                dev_err(&dev->intf->dev,
 705                        "Invalid channel number (%d)\n", es->channel);
 706                return;
 707        }
 708
 709        priv = dev->nets[es->channel];
 710        stats = &priv->netdev->stats;
 711
 712        /* Update all of the CAN interface's state and error counters before
 713         * trying any memory allocation that can actually fail with -ENOMEM.
 714         *
 715         * We send a temporary stack-allocated error CAN frame to
 716         * can_change_state() for the very same reason.
 717         *
 718         * TODO: Split can_change_state() responsibility between updating the
 719         * CAN interface's state and counters, and the setting up of CAN error
 720         * frame ID and data to userspace. Remove stack allocation afterwards.
 721         */
 722        old_state = priv->can.state;
 723        kvaser_usb_leaf_rx_error_update_can_state(priv, es, &tmp_cf);
 724        new_state = priv->can.state;
 725
 726        skb = alloc_can_err_skb(priv->netdev, &cf);
 727        if (!skb) {
 728                stats->rx_dropped++;
 729                return;
 730        }
 731        memcpy(cf, &tmp_cf, sizeof(*cf));
 732
 733        if (new_state != old_state) {
 734                if (es->status &
 735                    (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
 736                        if (!priv->can.restart_ms)
 737                                kvaser_usb_leaf_simple_cmd_async(priv,
 738                                                                 CMD_STOP_CHIP);
 739                        netif_carrier_off(priv->netdev);
 740                }
 741
 742                if (priv->can.restart_ms &&
 743                    old_state >= CAN_STATE_BUS_OFF &&
 744                    new_state < CAN_STATE_BUS_OFF) {
 745                        cf->can_id |= CAN_ERR_RESTARTED;
 746                        netif_carrier_on(priv->netdev);
 747                }
 748        }
 749
 750        switch (dev->card_data.leaf.family) {
 751        case KVASER_LEAF:
 752                if (es->leaf.error_factor) {
 753                        cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
 754
 755                        if (es->leaf.error_factor & M16C_EF_ACKE)
 756                                cf->data[3] = CAN_ERR_PROT_LOC_ACK;
 757                        if (es->leaf.error_factor & M16C_EF_CRCE)
 758                                cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
 759                        if (es->leaf.error_factor & M16C_EF_FORME)
 760                                cf->data[2] |= CAN_ERR_PROT_FORM;
 761                        if (es->leaf.error_factor & M16C_EF_STFE)
 762                                cf->data[2] |= CAN_ERR_PROT_STUFF;
 763                        if (es->leaf.error_factor & M16C_EF_BITE0)
 764                                cf->data[2] |= CAN_ERR_PROT_BIT0;
 765                        if (es->leaf.error_factor & M16C_EF_BITE1)
 766                                cf->data[2] |= CAN_ERR_PROT_BIT1;
 767                        if (es->leaf.error_factor & M16C_EF_TRE)
 768                                cf->data[2] |= CAN_ERR_PROT_TX;
 769                }
 770                break;
 771        case KVASER_USBCAN:
 772                if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
 773                        cf->can_id |= CAN_ERR_BUSERROR;
 774                break;
 775        }
 776
 777        cf->data[6] = es->txerr;
 778        cf->data[7] = es->rxerr;
 779
 780        stats->rx_packets++;
 781        stats->rx_bytes += cf->can_dlc;
 782        netif_rx(skb);
 783}
 784
 785/* For USBCAN, report error to userspace if the channels's errors counter
 786 * has changed, or we're the only channel seeing a bus error state.
 787 */
 788static void
 789kvaser_usb_leaf_usbcan_conditionally_rx_error(const struct kvaser_usb *dev,
 790                                              struct kvaser_usb_err_summary *es)
 791{
 792        struct kvaser_usb_net_priv *priv;
 793        unsigned int channel;
 794        bool report_error;
 795
 796        channel = es->channel;
 797        if (channel >= dev->nchannels) {
 798                dev_err(&dev->intf->dev,
 799                        "Invalid channel number (%d)\n", channel);
 800                return;
 801        }
 802
 803        priv = dev->nets[channel];
 804        report_error = false;
 805
 806        if (es->txerr != priv->bec.txerr) {
 807                es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR;
 808                report_error = true;
 809        }
 810        if (es->rxerr != priv->bec.rxerr) {
 811                es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR;
 812                report_error = true;
 813        }
 814        if ((es->status & M16C_STATE_BUS_ERROR) &&
 815            !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) {
 816                es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR;
 817                report_error = true;
 818        }
 819
 820        if (report_error)
 821                kvaser_usb_leaf_rx_error(dev, es);
 822}
 823
 824static void kvaser_usb_leaf_usbcan_rx_error(const struct kvaser_usb *dev,
 825                                            const struct kvaser_cmd *cmd)
 826{
 827        struct kvaser_usb_err_summary es = { };
 828
 829        switch (cmd->id) {
 830        /* Sometimes errors are sent as unsolicited chip state events */
 831        case CMD_CHIP_STATE_EVENT:
 832                es.channel = cmd->u.usbcan.chip_state_event.channel;
 833                es.status = cmd->u.usbcan.chip_state_event.status;
 834                es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count;
 835                es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count;
 836                kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
 837                break;
 838
 839        case CMD_CAN_ERROR_EVENT:
 840                es.channel = 0;
 841                es.status = cmd->u.usbcan.error_event.status_ch0;
 842                es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch0;
 843                es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch0;
 844                es.usbcan.other_ch_status =
 845                        cmd->u.usbcan.error_event.status_ch1;
 846                kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
 847
 848                /* The USBCAN firmware supports up to 2 channels.
 849                 * Now that ch0 was checked, check if ch1 has any errors.
 850                 */
 851                if (dev->nchannels == MAX_USBCAN_NET_DEVICES) {
 852                        es.channel = 1;
 853                        es.status = cmd->u.usbcan.error_event.status_ch1;
 854                        es.txerr =
 855                                cmd->u.usbcan.error_event.tx_errors_count_ch1;
 856                        es.rxerr =
 857                                cmd->u.usbcan.error_event.rx_errors_count_ch1;
 858                        es.usbcan.other_ch_status =
 859                                cmd->u.usbcan.error_event.status_ch0;
 860                        kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
 861                }
 862                break;
 863
 864        default:
 865                dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
 866        }
 867}
 868
 869static void kvaser_usb_leaf_leaf_rx_error(const struct kvaser_usb *dev,
 870                                          const struct kvaser_cmd *cmd)
 871{
 872        struct kvaser_usb_err_summary es = { };
 873
 874        switch (cmd->id) {
 875        case CMD_CAN_ERROR_EVENT:
 876                es.channel = cmd->u.leaf.error_event.channel;
 877                es.status = cmd->u.leaf.error_event.status;
 878                es.txerr = cmd->u.leaf.error_event.tx_errors_count;
 879                es.rxerr = cmd->u.leaf.error_event.rx_errors_count;
 880                es.leaf.error_factor = cmd->u.leaf.error_event.error_factor;
 881                break;
 882        case CMD_LEAF_LOG_MESSAGE:
 883                es.channel = cmd->u.leaf.log_message.channel;
 884                es.status = cmd->u.leaf.log_message.data[0];
 885                es.txerr = cmd->u.leaf.log_message.data[2];
 886                es.rxerr = cmd->u.leaf.log_message.data[3];
 887                es.leaf.error_factor = cmd->u.leaf.log_message.data[1];
 888                break;
 889        case CMD_CHIP_STATE_EVENT:
 890                es.channel = cmd->u.leaf.chip_state_event.channel;
 891                es.status = cmd->u.leaf.chip_state_event.status;
 892                es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;
 893                es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;
 894                es.leaf.error_factor = 0;
 895                break;
 896        default:
 897                dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
 898                return;
 899        }
 900
 901        kvaser_usb_leaf_rx_error(dev, &es);
 902}
 903
 904static void kvaser_usb_leaf_rx_can_err(const struct kvaser_usb_net_priv *priv,
 905                                       const struct kvaser_cmd *cmd)
 906{
 907        if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
 908                                         MSG_FLAG_NERR)) {
 909                struct net_device_stats *stats = &priv->netdev->stats;
 910
 911                netdev_err(priv->netdev, "Unknown error (flags: 0x%02x)\n",
 912                           cmd->u.rx_can_header.flag);
 913
 914                stats->rx_errors++;
 915                return;
 916        }
 917
 918        if (cmd->u.rx_can_header.flag & MSG_FLAG_OVERRUN)
 919                kvaser_usb_can_rx_over_error(priv->netdev);
 920}
 921
 922static void kvaser_usb_leaf_rx_can_msg(const struct kvaser_usb *dev,
 923                                       const struct kvaser_cmd *cmd)
 924{
 925        struct kvaser_usb_net_priv *priv;
 926        struct can_frame *cf;
 927        struct sk_buff *skb;
 928        struct net_device_stats *stats;
 929        u8 channel = cmd->u.rx_can_header.channel;
 930        const u8 *rx_data = NULL;       /* GCC */
 931
 932        if (channel >= dev->nchannels) {
 933                dev_err(&dev->intf->dev,
 934                        "Invalid channel number (%d)\n", channel);
 935                return;
 936        }
 937
 938        priv = dev->nets[channel];
 939        stats = &priv->netdev->stats;
 940
 941        if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
 942            (dev->card_data.leaf.family == KVASER_LEAF &&
 943             cmd->id == CMD_LEAF_LOG_MESSAGE)) {
 944                kvaser_usb_leaf_leaf_rx_error(dev, cmd);
 945                return;
 946        } else if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
 947                                                MSG_FLAG_NERR |
 948                                                MSG_FLAG_OVERRUN)) {
 949                kvaser_usb_leaf_rx_can_err(priv, cmd);
 950                return;
 951        } else if (cmd->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
 952                netdev_warn(priv->netdev,
 953                            "Unhandled frame (flags: 0x%02x)\n",
 954                            cmd->u.rx_can_header.flag);
 955                return;
 956        }
 957
 958        switch (dev->card_data.leaf.family) {
 959        case KVASER_LEAF:
 960                rx_data = cmd->u.leaf.rx_can.data;
 961                break;
 962        case KVASER_USBCAN:
 963                rx_data = cmd->u.usbcan.rx_can.data;
 964                break;
 965        }
 966
 967        skb = alloc_can_skb(priv->netdev, &cf);
 968        if (!skb) {
 969                stats->rx_dropped++;
 970                return;
 971        }
 972
 973        if (dev->card_data.leaf.family == KVASER_LEAF && cmd->id ==
 974            CMD_LEAF_LOG_MESSAGE) {
 975                cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id);
 976                if (cf->can_id & KVASER_EXTENDED_FRAME)
 977                        cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG;
 978                else
 979                        cf->can_id &= CAN_SFF_MASK;
 980
 981                cf->can_dlc = get_can_dlc(cmd->u.leaf.log_message.dlc);
 982
 983                if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
 984                        cf->can_id |= CAN_RTR_FLAG;
 985                else
 986                        memcpy(cf->data, &cmd->u.leaf.log_message.data,
 987                               cf->can_dlc);
 988        } else {
 989                cf->can_id = ((rx_data[0] & 0x1f) << 6) | (rx_data[1] & 0x3f);
 990
 991                if (cmd->id == CMD_RX_EXT_MESSAGE) {
 992                        cf->can_id <<= 18;
 993                        cf->can_id |= ((rx_data[2] & 0x0f) << 14) |
 994                                      ((rx_data[3] & 0xff) << 6) |
 995                                      (rx_data[4] & 0x3f);
 996                        cf->can_id |= CAN_EFF_FLAG;
 997                }
 998
 999                cf->can_dlc = get_can_dlc(rx_data[5]);
1000
1001                if (cmd->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
1002                        cf->can_id |= CAN_RTR_FLAG;
1003                else
1004                        memcpy(cf->data, &rx_data[6], cf->can_dlc);
1005        }
1006
1007        stats->rx_packets++;
1008        stats->rx_bytes += cf->can_dlc;
1009        netif_rx(skb);
1010}
1011
1012static void kvaser_usb_leaf_start_chip_reply(const struct kvaser_usb *dev,
1013                                             const struct kvaser_cmd *cmd)
1014{
1015        struct kvaser_usb_net_priv *priv;
1016        u8 channel = cmd->u.simple.channel;
1017
1018        if (channel >= dev->nchannels) {
1019                dev_err(&dev->intf->dev,
1020                        "Invalid channel number (%d)\n", channel);
1021                return;
1022        }
1023
1024        priv = dev->nets[channel];
1025
1026        if (completion_done(&priv->start_comp) &&
1027            netif_queue_stopped(priv->netdev)) {
1028                netif_wake_queue(priv->netdev);
1029        } else {
1030                netif_start_queue(priv->netdev);
1031                complete(&priv->start_comp);
1032        }
1033}
1034
1035static void kvaser_usb_leaf_stop_chip_reply(const struct kvaser_usb *dev,
1036                                            const struct kvaser_cmd *cmd)
1037{
1038        struct kvaser_usb_net_priv *priv;
1039        u8 channel = cmd->u.simple.channel;
1040
1041        if (channel >= dev->nchannels) {
1042                dev_err(&dev->intf->dev,
1043                        "Invalid channel number (%d)\n", channel);
1044                return;
1045        }
1046
1047        priv = dev->nets[channel];
1048
1049        complete(&priv->stop_comp);
1050}
1051
1052static void kvaser_usb_leaf_handle_command(const struct kvaser_usb *dev,
1053                                           const struct kvaser_cmd *cmd)
1054{
1055        switch (cmd->id) {
1056        case CMD_START_CHIP_REPLY:
1057                kvaser_usb_leaf_start_chip_reply(dev, cmd);
1058                break;
1059
1060        case CMD_STOP_CHIP_REPLY:
1061                kvaser_usb_leaf_stop_chip_reply(dev, cmd);
1062                break;
1063
1064        case CMD_RX_STD_MESSAGE:
1065        case CMD_RX_EXT_MESSAGE:
1066                kvaser_usb_leaf_rx_can_msg(dev, cmd);
1067                break;
1068
1069        case CMD_LEAF_LOG_MESSAGE:
1070                if (dev->card_data.leaf.family != KVASER_LEAF)
1071                        goto warn;
1072                kvaser_usb_leaf_rx_can_msg(dev, cmd);
1073                break;
1074
1075        case CMD_CHIP_STATE_EVENT:
1076        case CMD_CAN_ERROR_EVENT:
1077                if (dev->card_data.leaf.family == KVASER_LEAF)
1078                        kvaser_usb_leaf_leaf_rx_error(dev, cmd);
1079                else
1080                        kvaser_usb_leaf_usbcan_rx_error(dev, cmd);
1081                break;
1082
1083        case CMD_TX_ACKNOWLEDGE:
1084                kvaser_usb_leaf_tx_acknowledge(dev, cmd);
1085                break;
1086
1087        /* Ignored commands */
1088        case CMD_USBCAN_CLOCK_OVERFLOW_EVENT:
1089                if (dev->card_data.leaf.family != KVASER_USBCAN)
1090                        goto warn;
1091                break;
1092
1093        case CMD_FLUSH_QUEUE_REPLY:
1094                if (dev->card_data.leaf.family != KVASER_LEAF)
1095                        goto warn;
1096                break;
1097
1098        default:
1099warn:           dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", cmd->id);
1100                break;
1101        }
1102}
1103
1104static void kvaser_usb_leaf_read_bulk_callback(struct kvaser_usb *dev,
1105                                               void *buf, int len)
1106{
1107        struct kvaser_cmd *cmd;
1108        int pos = 0;
1109
1110        while (pos <= len - CMD_HEADER_LEN) {
1111                cmd = buf + pos;
1112
1113                /* The Kvaser firmware can only read and write commands that
1114                 * does not cross the USB's endpoint wMaxPacketSize boundary.
1115                 * If a follow-up command crosses such boundary, firmware puts
1116                 * a placeholder zero-length command in its place then aligns
1117                 * the real command to the next max packet size.
1118                 *
1119                 * Handle such cases or we're going to miss a significant
1120                 * number of events in case of a heavy rx load on the bus.
1121                 */
1122                if (cmd->len == 0) {
1123                        pos = round_up(pos, le16_to_cpu
1124                                                (dev->bulk_in->wMaxPacketSize));
1125                        continue;
1126                }
1127
1128                if (pos + cmd->len > len) {
1129                        dev_err_ratelimited(&dev->intf->dev, "Format error\n");
1130                        break;
1131                }
1132
1133                kvaser_usb_leaf_handle_command(dev, cmd);
1134                pos += cmd->len;
1135        }
1136}
1137
1138static int kvaser_usb_leaf_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1139{
1140        struct kvaser_cmd *cmd;
1141        int rc;
1142
1143        cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1144        if (!cmd)
1145                return -ENOMEM;
1146
1147        cmd->id = CMD_SET_CTRL_MODE;
1148        cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_ctrl_mode);
1149        cmd->u.ctrl_mode.tid = 0xff;
1150        cmd->u.ctrl_mode.channel = priv->channel;
1151
1152        if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1153                cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1154        else
1155                cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1156
1157        rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1158
1159        kfree(cmd);
1160        return rc;
1161}
1162
1163static int kvaser_usb_leaf_start_chip(struct kvaser_usb_net_priv *priv)
1164{
1165        int err;
1166
1167        init_completion(&priv->start_comp);
1168
1169        err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_START_CHIP,
1170                                              priv->channel);
1171        if (err)
1172                return err;
1173
1174        if (!wait_for_completion_timeout(&priv->start_comp,
1175                                         msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1176                return -ETIMEDOUT;
1177
1178        return 0;
1179}
1180
1181static int kvaser_usb_leaf_stop_chip(struct kvaser_usb_net_priv *priv)
1182{
1183        int err;
1184
1185        init_completion(&priv->stop_comp);
1186
1187        err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_STOP_CHIP,
1188                                              priv->channel);
1189        if (err)
1190                return err;
1191
1192        if (!wait_for_completion_timeout(&priv->stop_comp,
1193                                         msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1194                return -ETIMEDOUT;
1195
1196        return 0;
1197}
1198
1199static int kvaser_usb_leaf_reset_chip(struct kvaser_usb *dev, int channel)
1200{
1201        return kvaser_usb_leaf_send_simple_cmd(dev, CMD_RESET_CHIP, channel);
1202}
1203
1204static int kvaser_usb_leaf_flush_queue(struct kvaser_usb_net_priv *priv)
1205{
1206        struct kvaser_cmd *cmd;
1207        int rc;
1208
1209        cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1210        if (!cmd)
1211                return -ENOMEM;
1212
1213        cmd->id = CMD_FLUSH_QUEUE;
1214        cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_flush_queue);
1215        cmd->u.flush_queue.channel = priv->channel;
1216        cmd->u.flush_queue.flags = 0x00;
1217
1218        rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1219
1220        kfree(cmd);
1221        return rc;
1222}
1223
1224static int kvaser_usb_leaf_init_card(struct kvaser_usb *dev)
1225{
1226        struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
1227
1228        dev->cfg = &kvaser_usb_leaf_dev_cfg;
1229        card_data->ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1230
1231        return 0;
1232}
1233
1234static const struct can_bittiming_const kvaser_usb_leaf_bittiming_const = {
1235        .name = "kvaser_usb",
1236        .tseg1_min = KVASER_USB_TSEG1_MIN,
1237        .tseg1_max = KVASER_USB_TSEG1_MAX,
1238        .tseg2_min = KVASER_USB_TSEG2_MIN,
1239        .tseg2_max = KVASER_USB_TSEG2_MAX,
1240        .sjw_max = KVASER_USB_SJW_MAX,
1241        .brp_min = KVASER_USB_BRP_MIN,
1242        .brp_max = KVASER_USB_BRP_MAX,
1243        .brp_inc = KVASER_USB_BRP_INC,
1244};
1245
1246static int kvaser_usb_leaf_set_bittiming(struct net_device *netdev)
1247{
1248        struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1249        struct can_bittiming *bt = &priv->can.bittiming;
1250        struct kvaser_usb *dev = priv->dev;
1251        struct kvaser_cmd *cmd;
1252        int rc;
1253
1254        cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1255        if (!cmd)
1256                return -ENOMEM;
1257
1258        cmd->id = CMD_SET_BUS_PARAMS;
1259        cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_busparams);
1260        cmd->u.busparams.channel = priv->channel;
1261        cmd->u.busparams.tid = 0xff;
1262        cmd->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
1263        cmd->u.busparams.sjw = bt->sjw;
1264        cmd->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
1265        cmd->u.busparams.tseg2 = bt->phase_seg2;
1266
1267        if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1268                cmd->u.busparams.no_samp = 3;
1269        else
1270                cmd->u.busparams.no_samp = 1;
1271
1272        rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
1273
1274        kfree(cmd);
1275        return rc;
1276}
1277
1278static int kvaser_usb_leaf_set_mode(struct net_device *netdev,
1279                                    enum can_mode mode)
1280{
1281        struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1282        int err;
1283
1284        switch (mode) {
1285        case CAN_MODE_START:
1286                err = kvaser_usb_leaf_simple_cmd_async(priv, CMD_START_CHIP);
1287                if (err)
1288                        return err;
1289                break;
1290        default:
1291                return -EOPNOTSUPP;
1292        }
1293
1294        return 0;
1295}
1296
1297static int kvaser_usb_leaf_get_berr_counter(const struct net_device *netdev,
1298                                            struct can_berr_counter *bec)
1299{
1300        struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1301
1302        *bec = priv->bec;
1303
1304        return 0;
1305}
1306
1307static int kvaser_usb_leaf_setup_endpoints(struct kvaser_usb *dev)
1308{
1309        const struct usb_host_interface *iface_desc;
1310        struct usb_endpoint_descriptor *endpoint;
1311        int i;
1312
1313        iface_desc = &dev->intf->altsetting[0];
1314
1315        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1316                endpoint = &iface_desc->endpoint[i].desc;
1317
1318                if (!dev->bulk_in && usb_endpoint_is_bulk_in(endpoint))
1319                        dev->bulk_in = endpoint;
1320
1321                if (!dev->bulk_out && usb_endpoint_is_bulk_out(endpoint))
1322                        dev->bulk_out = endpoint;
1323
1324                /* use first bulk endpoint for in and out */
1325                if (dev->bulk_in && dev->bulk_out)
1326                        return 0;
1327        }
1328
1329        return -ENODEV;
1330}
1331
1332const struct kvaser_usb_dev_ops kvaser_usb_leaf_dev_ops = {
1333        .dev_set_mode = kvaser_usb_leaf_set_mode,
1334        .dev_set_bittiming = kvaser_usb_leaf_set_bittiming,
1335        .dev_set_data_bittiming = NULL,
1336        .dev_get_berr_counter = kvaser_usb_leaf_get_berr_counter,
1337        .dev_setup_endpoints = kvaser_usb_leaf_setup_endpoints,
1338        .dev_init_card = kvaser_usb_leaf_init_card,
1339        .dev_get_software_info = kvaser_usb_leaf_get_software_info,
1340        .dev_get_software_details = NULL,
1341        .dev_get_card_info = kvaser_usb_leaf_get_card_info,
1342        .dev_get_capabilities = NULL,
1343        .dev_set_opt_mode = kvaser_usb_leaf_set_opt_mode,
1344        .dev_start_chip = kvaser_usb_leaf_start_chip,
1345        .dev_stop_chip = kvaser_usb_leaf_stop_chip,
1346        .dev_reset_chip = kvaser_usb_leaf_reset_chip,
1347        .dev_flush_queue = kvaser_usb_leaf_flush_queue,
1348        .dev_read_bulk_callback = kvaser_usb_leaf_read_bulk_callback,
1349        .dev_frame_to_cmd = kvaser_usb_leaf_frame_to_cmd,
1350};
1351
1352static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg = {
1353        .clock = {
1354                .freq = CAN_USB_CLOCK,
1355        },
1356        .timestamp_freq = 1,
1357        .bittiming_const = &kvaser_usb_leaf_bittiming_const,
1358};
1359