drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Parts of this driver are based on the following:
   3  *  - Kvaser linux leaf driver (version 4.78)
   4  *  - CAN driver for esd CAN-USB/2
   5  *  - Kvaser linux usbcanII driver (version 5.3)
   6  *
   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 */
  32 static 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
 120 struct kvaser_cmd_simple {
 121         u8 tid;
 122         u8 channel;
 123 } __packed;
 124
 125 struct 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
 145 struct 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
 154 struct 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
 164 struct 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
 174 struct 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
 190 struct kvaser_cmd_rx_can_header {
 191         u8 channel;
 192         u8 flag;
 193 } __packed;
 194
 195 struct leaf_cmd_rx_can {
 196         u8 channel;
 197         u8 flag;
 198
 199         __le16 time[3];
 200         u8 data[14];
 201 } __packed;
 202
 203 struct usbcan_cmd_rx_can {
 204         u8 channel;
 205         u8 flag;
 206
 207         u8 data[14];
 208         __le16 time;
 209 } __packed;
 210
 211 struct 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
 223 struct 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
 235 struct kvaser_cmd_tx_acknowledge_header {
 236         u8 channel;
 237         u8 tid;
 238 } __packed;
 239
 240 struct 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
 252 struct 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
 264 struct kvaser_cmd_ctrl_mode {
 265         u8 tid;
 266         u8 channel;
 267         u8 ctrl_mode;
 268         u8 padding[3];
 269 } __packed;
 270
 271 struct kvaser_cmd_flush_queue {
 272         u8 tid;
 273         u8 channel;
 274         u8 flags;
 275         u8 padding[3];
 276 } __packed;
 277
 278 struct 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
 288 struct 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  */
 330 struct 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
 343 static void *
 344 kvaser_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
 395 static 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
 447 end:
 448         kfree(buf);
 449
 450         return err;
 451 }
 452
 453 static 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
 474 static 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
 503 static 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
 520 static 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
 542 static 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
 605 static 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
 626 static void
 627 kvaser_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
 692 static 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  */
 788 static void
 789 kvaser_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
 824 static 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
 869 static 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
 904 static 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
 922 static 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
1012 static 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
1035 static 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
1052 static 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:
1099 warn:           dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", cmd->id);
1100                 break;
1101         }
1102 }
1103
1104 static 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
1138 static 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
1163 static 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
1181 static 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
1199 static 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
1204 static 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
1224 static 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
1234 static 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
1246 static 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
1278 static 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
1297 static 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
1307 static 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
1332 const 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
1352 static 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 };