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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Parts of this driver are based on the following:
   3  *  - Kvaser linux mhydra driver (version 5.24)
   4  *  - CAN driver for esd CAN-USB/2
   5  *
   6  * Copyright (C) 2018 KVASER AB, Sweden. All rights reserved.
   7  * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
   8  *
   9  * Known issues:
  10  *  - Transition from CAN_STATE_ERROR_WARNING to CAN_STATE_ERROR_ACTIVE is only
  11  *    reported after a call to do_get_berr_counter(), since firmware does not
  12  *    distinguish between ERROR_WARNING and ERROR_ACTIVE.
  13  *  - Hardware timestamps are not set for CAN Tx frames.
  14  */
  15
  16 #include <linux/completion.h>
  17 #include <linux/device.h>
  18 #include <linux/gfp.h>
  19 #include <linux/jiffies.h>
  20 #include <linux/kernel.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/string.h>
  24 #include <linux/types.h>
  25 #include <linux/usb.h>
  26
  27 #include <linux/can.h>
  28 #include <linux/can/dev.h>
  29 #include <linux/can/error.h>
  30 #include <linux/can/netlink.h>
  31
  32 #include "kvaser_usb.h"
  33
  34 /* Forward declarations */
  35 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_kcan;
  36 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_flexc;
  37
  38 #define KVASER_USB_HYDRA_BULK_EP_IN_ADDR        0x82
  39 #define KVASER_USB_HYDRA_BULK_EP_OUT_ADDR       0x02
  40
  41 #define KVASER_USB_HYDRA_MAX_TRANSID            0xff
  42 #define KVASER_USB_HYDRA_MIN_TRANSID            0x01
  43
  44 /* Minihydra command IDs */
  45 #define CMD_SET_BUSPARAMS_REQ                   16
  46 #define CMD_GET_CHIP_STATE_REQ                  19
  47 #define CMD_CHIP_STATE_EVENT                    20
  48 #define CMD_SET_DRIVERMODE_REQ                  21
  49 #define CMD_START_CHIP_REQ                      26
  50 #define CMD_START_CHIP_RESP                     27
  51 #define CMD_STOP_CHIP_REQ                       28
  52 #define CMD_STOP_CHIP_RESP                      29
  53 #define CMD_TX_CAN_MESSAGE                      33
  54 #define CMD_GET_CARD_INFO_REQ                   34
  55 #define CMD_GET_CARD_INFO_RESP                  35
  56 #define CMD_GET_SOFTWARE_INFO_REQ               38
  57 #define CMD_GET_SOFTWARE_INFO_RESP              39
  58 #define CMD_ERROR_EVENT                         45
  59 #define CMD_FLUSH_QUEUE                         48
  60 #define CMD_TX_ACKNOWLEDGE                      50
  61 #define CMD_FLUSH_QUEUE_RESP                    66
  62 #define CMD_SET_BUSPARAMS_FD_REQ                69
  63 #define CMD_SET_BUSPARAMS_FD_RESP               70
  64 #define CMD_SET_BUSPARAMS_RESP                  85
  65 #define CMD_GET_CAPABILITIES_REQ                95
  66 #define CMD_GET_CAPABILITIES_RESP               96
  67 #define CMD_RX_MESSAGE                          106
  68 #define CMD_MAP_CHANNEL_REQ                     200
  69 #define CMD_MAP_CHANNEL_RESP                    201
  70 #define CMD_GET_SOFTWARE_DETAILS_REQ            202
  71 #define CMD_GET_SOFTWARE_DETAILS_RESP           203
  72 #define CMD_EXTENDED                            255
  73
  74 /* Minihydra extended command IDs */
  75 #define CMD_TX_CAN_MESSAGE_FD                   224
  76 #define CMD_TX_ACKNOWLEDGE_FD                   225
  77 #define CMD_RX_MESSAGE_FD                       226
  78
  79 /* Hydra commands are handled by different threads in firmware.
  80  * The threads are denoted hydra entity (HE). Each HE got a unique 6-bit
  81  * address. The address is used in hydra commands to get/set source and
  82  * destination HE. There are two predefined HE addresses, the remaining
  83  * addresses are different between devices and firmware versions. Hence, we need
  84  * to enumerate the addresses (see kvaser_usb_hydra_map_channel()).
  85  */
  86
  87 /* Well-known HE addresses */
  88 #define KVASER_USB_HYDRA_HE_ADDRESS_ROUTER      0x00
  89 #define KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL     0x3e
  90
  91 #define KVASER_USB_HYDRA_TRANSID_CANHE          0x40
  92 #define KVASER_USB_HYDRA_TRANSID_SYSDBG         0x61
  93
  94 struct kvaser_cmd_map_ch_req {
  95         char name[16];
  96         u8 channel;
  97         u8 reserved[11];
  98 } __packed;
  99
 100 struct kvaser_cmd_map_ch_res {
 101         u8 he_addr;
 102         u8 channel;
 103         u8 reserved[26];
 104 } __packed;
 105
 106 struct kvaser_cmd_card_info {
 107         __le32 serial_number;
 108         __le32 clock_res;
 109         __le32 mfg_date;
 110         __le32 ean[2];
 111         u8 hw_version;
 112         u8 usb_mode;
 113         u8 hw_type;
 114         u8 reserved0;
 115         u8 nchannels;
 116         u8 reserved1[3];
 117 } __packed;
 118
 119 struct kvaser_cmd_sw_info {
 120         u8 reserved0[8];
 121         __le16 max_outstanding_tx;
 122         u8 reserved1[18];
 123 } __packed;
 124
 125 struct kvaser_cmd_sw_detail_req {
 126         u8 use_ext_cmd;
 127         u8 reserved[27];
 128 } __packed;
 129
 130 /* Software detail flags */
 131 #define KVASER_USB_HYDRA_SW_FLAG_FW_BETA        BIT(2)
 132 #define KVASER_USB_HYDRA_SW_FLAG_FW_BAD         BIT(4)
 133 #define KVASER_USB_HYDRA_SW_FLAG_FREQ_80M       BIT(5)
 134 #define KVASER_USB_HYDRA_SW_FLAG_EXT_CMD        BIT(9)
 135 #define KVASER_USB_HYDRA_SW_FLAG_CANFD          BIT(10)
 136 #define KVASER_USB_HYDRA_SW_FLAG_NONISO         BIT(11)
 137 #define KVASER_USB_HYDRA_SW_FLAG_EXT_CAP        BIT(12)
 138 struct kvaser_cmd_sw_detail_res {
 139         __le32 sw_flags;
 140         __le32 sw_version;
 141         __le32 sw_name;
 142         __le32 ean[2];
 143         __le32 max_bitrate;
 144         u8 reserved[4];
 145 } __packed;
 146
 147 /* Sub commands for cap_req and cap_res */
 148 #define KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE    0x02
 149 #define KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT     0x05
 150 #define KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT       0x06
 151 struct kvaser_cmd_cap_req {
 152         __le16 cap_cmd;
 153         u8 reserved[26];
 154 } __packed;
 155
 156 /* Status codes for cap_res */
 157 #define KVASER_USB_HYDRA_CAP_STAT_OK            0x00
 158 #define KVASER_USB_HYDRA_CAP_STAT_NOT_IMPL      0x01
 159 #define KVASER_USB_HYDRA_CAP_STAT_UNAVAIL       0x02
 160 struct kvaser_cmd_cap_res {
 161         __le16 cap_cmd;
 162         __le16 status;
 163         __le32 mask;
 164         __le32 value;
 165         u8 reserved[16];
 166 } __packed;
 167
 168 /* CMD_ERROR_EVENT error codes */
 169 #define KVASER_USB_HYDRA_ERROR_EVENT_CAN        0x01
 170 #define KVASER_USB_HYDRA_ERROR_EVENT_PARAM      0x09
 171 struct kvaser_cmd_error_event {
 172         __le16 timestamp[3];
 173         u8 reserved;
 174         u8 error_code;
 175         __le16 info1;
 176         __le16 info2;
 177 } __packed;
 178
 179 /* Chip state status flags. Used for chip_state_event and err_frame_data. */
 180 #define KVASER_USB_HYDRA_BUS_ERR_ACT            0x00
 181 #define KVASER_USB_HYDRA_BUS_ERR_PASS           BIT(5)
 182 #define KVASER_USB_HYDRA_BUS_BUS_OFF            BIT(6)
 183 struct kvaser_cmd_chip_state_event {
 184         __le16 timestamp[3];
 185         u8 tx_err_counter;
 186         u8 rx_err_counter;
 187         u8 bus_status;
 188         u8 reserved[19];
 189 } __packed;
 190
 191 /* Busparam modes */
 192 #define KVASER_USB_HYDRA_BUS_MODE_CAN           0x00
 193 #define KVASER_USB_HYDRA_BUS_MODE_CANFD_ISO     0x01
 194 #define KVASER_USB_HYDRA_BUS_MODE_NONISO        0x02
 195 struct kvaser_cmd_set_busparams {
 196         __le32 bitrate;
 197         u8 tseg1;
 198         u8 tseg2;
 199         u8 sjw;
 200         u8 nsamples;
 201         u8 reserved0[4];
 202         __le32 bitrate_d;
 203         u8 tseg1_d;
 204         u8 tseg2_d;
 205         u8 sjw_d;
 206         u8 nsamples_d;
 207         u8 canfd_mode;
 208         u8 reserved1[7];
 209 } __packed;
 210
 211 /* Ctrl modes */
 212 #define KVASER_USB_HYDRA_CTRLMODE_NORMAL        0x01
 213 #define KVASER_USB_HYDRA_CTRLMODE_LISTEN        0x02
 214 struct kvaser_cmd_set_ctrlmode {
 215         u8 mode;
 216         u8 reserved[27];
 217 } __packed;
 218
 219 struct kvaser_err_frame_data {
 220         u8 bus_status;
 221         u8 reserved0;
 222         u8 tx_err_counter;
 223         u8 rx_err_counter;
 224         u8 reserved1[4];
 225 } __packed;
 226
 227 struct kvaser_cmd_rx_can {
 228         u8 cmd_len;
 229         u8 cmd_no;
 230         u8 channel;
 231         u8 flags;
 232         __le16 timestamp[3];
 233         u8 dlc;
 234         u8 padding;
 235         __le32 id;
 236         union {
 237                 u8 data[8];
 238                 struct kvaser_err_frame_data err_frame_data;
 239         };
 240 } __packed;
 241
 242 /* Extended CAN ID flag. Used in rx_can and tx_can */
 243 #define KVASER_USB_HYDRA_EXTENDED_FRAME_ID      BIT(31)
 244 struct kvaser_cmd_tx_can {
 245         __le32 id;
 246         u8 data[8];
 247         u8 dlc;
 248         u8 flags;
 249         __le16 transid;
 250         u8 channel;
 251         u8 reserved[11];
 252 } __packed;
 253
 254 struct kvaser_cmd_header {
 255         u8 cmd_no;
 256         /* The destination HE address is stored in 0..5 of he_addr.
 257          * The upper part of source HE address is stored in 6..7 of he_addr, and
 258          * the lower part is stored in 12..15 of transid.
 259          */
 260         u8 he_addr;
 261         __le16 transid;
 262 } __packed;
 263
 264 struct kvaser_cmd {
 265         struct kvaser_cmd_header header;
 266         union {
 267                 struct kvaser_cmd_map_ch_req map_ch_req;
 268                 struct kvaser_cmd_map_ch_res map_ch_res;
 269
 270                 struct kvaser_cmd_card_info card_info;
 271                 struct kvaser_cmd_sw_info sw_info;
 272                 struct kvaser_cmd_sw_detail_req sw_detail_req;
 273                 struct kvaser_cmd_sw_detail_res sw_detail_res;
 274
 275                 struct kvaser_cmd_cap_req cap_req;
 276                 struct kvaser_cmd_cap_res cap_res;
 277
 278                 struct kvaser_cmd_error_event error_event;
 279
 280                 struct kvaser_cmd_set_busparams set_busparams_req;
 281
 282                 struct kvaser_cmd_chip_state_event chip_state_event;
 283
 284                 struct kvaser_cmd_set_ctrlmode set_ctrlmode;
 285
 286                 struct kvaser_cmd_rx_can rx_can;
 287                 struct kvaser_cmd_tx_can tx_can;
 288         } __packed;
 289 } __packed;
 290
 291 /* CAN frame flags. Used in rx_can, ext_rx_can, tx_can and ext_tx_can */
 292 #define KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME    BIT(0)
 293 #define KVASER_USB_HYDRA_CF_FLAG_OVERRUN        BIT(1)
 294 #define KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME   BIT(4)
 295 #define KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID    BIT(5)
 296 /* CAN frame flags. Used in ext_rx_can and ext_tx_can */
 297 #define KVASER_USB_HYDRA_CF_FLAG_OSM_NACK       BIT(12)
 298 #define KVASER_USB_HYDRA_CF_FLAG_ABL            BIT(13)
 299 #define KVASER_USB_HYDRA_CF_FLAG_FDF            BIT(16)
 300 #define KVASER_USB_HYDRA_CF_FLAG_BRS            BIT(17)
 301 #define KVASER_USB_HYDRA_CF_FLAG_ESI            BIT(18)
 302
 303 /* KCAN packet header macros. Used in ext_rx_can and ext_tx_can */
 304 #define KVASER_USB_KCAN_DATA_DLC_BITS           4
 305 #define KVASER_USB_KCAN_DATA_DLC_SHIFT          8
 306 #define KVASER_USB_KCAN_DATA_DLC_MASK \
 307                                 GENMASK(KVASER_USB_KCAN_DATA_DLC_BITS - 1 + \
 308                                 KVASER_USB_KCAN_DATA_DLC_SHIFT, \
 309                                 KVASER_USB_KCAN_DATA_DLC_SHIFT)
 310
 311 #define KVASER_USB_KCAN_DATA_BRS                BIT(14)
 312 #define KVASER_USB_KCAN_DATA_FDF                BIT(15)
 313 #define KVASER_USB_KCAN_DATA_OSM                BIT(16)
 314 #define KVASER_USB_KCAN_DATA_AREQ               BIT(31)
 315 #define KVASER_USB_KCAN_DATA_SRR                BIT(31)
 316 #define KVASER_USB_KCAN_DATA_RTR                BIT(29)
 317 #define KVASER_USB_KCAN_DATA_IDE                BIT(30)
 318 struct kvaser_cmd_ext_rx_can {
 319         __le32 flags;
 320         __le32 id;
 321         __le32 kcan_id;
 322         __le32 kcan_header;
 323         __le64 timestamp;
 324         union {
 325                 u8 kcan_payload[64];
 326                 struct kvaser_err_frame_data err_frame_data;
 327         };
 328 } __packed;
 329
 330 struct kvaser_cmd_ext_tx_can {
 331         __le32 flags;
 332         __le32 id;
 333         __le32 kcan_id;
 334         __le32 kcan_header;
 335         u8 databytes;
 336         u8 dlc;
 337         u8 reserved[6];
 338         u8 kcan_payload[64];
 339 } __packed;
 340
 341 struct kvaser_cmd_ext_tx_ack {
 342         __le32 flags;
 343         u8 reserved0[4];
 344         __le64 timestamp;
 345         u8 reserved1[8];
 346 } __packed;
 347
 348 /* struct for extended commands (CMD_EXTENDED) */
 349 struct kvaser_cmd_ext {
 350         struct kvaser_cmd_header header;
 351         __le16 len;
 352         u8 cmd_no_ext;
 353         u8 reserved;
 354
 355         union {
 356                 struct kvaser_cmd_ext_rx_can rx_can;
 357                 struct kvaser_cmd_ext_tx_can tx_can;
 358                 struct kvaser_cmd_ext_tx_ack tx_ack;
 359         } __packed;
 360 } __packed;
 361
 362 static const struct can_bittiming_const kvaser_usb_hydra_kcan_bittiming_c = {
 363         .name = "kvaser_usb_kcan",
 364         .tseg1_min = 1,
 365         .tseg1_max = 255,
 366         .tseg2_min = 1,
 367         .tseg2_max = 32,
 368         .sjw_max = 16,
 369         .brp_min = 1,
 370         .brp_max = 4096,
 371         .brp_inc = 1,
 372 };
 373
 374 static const struct can_bittiming_const kvaser_usb_hydra_flexc_bittiming_c = {
 375         .name = "kvaser_usb_flex",
 376         .tseg1_min = 4,
 377         .tseg1_max = 16,
 378         .tseg2_min = 2,
 379         .tseg2_max = 8,
 380         .sjw_max = 4,
 381         .brp_min = 1,
 382         .brp_max = 256,
 383         .brp_inc = 1,
 384 };
 385
 386 #define KVASER_USB_HYDRA_TRANSID_BITS           12
 387 #define KVASER_USB_HYDRA_TRANSID_MASK \
 388                                 GENMASK(KVASER_USB_HYDRA_TRANSID_BITS - 1, 0)
 389 #define KVASER_USB_HYDRA_HE_ADDR_SRC_MASK       GENMASK(7, 6)
 390 #define KVASER_USB_HYDRA_HE_ADDR_DEST_MASK      GENMASK(5, 0)
 391 #define KVASER_USB_HYDRA_HE_ADDR_SRC_BITS       2
 392 static inline u16 kvaser_usb_hydra_get_cmd_transid(const struct kvaser_cmd *cmd)
 393 {
 394         return le16_to_cpu(cmd->header.transid) & KVASER_USB_HYDRA_TRANSID_MASK;
 395 }
 396
 397 static inline void kvaser_usb_hydra_set_cmd_transid(struct kvaser_cmd *cmd,
 398                                                     u16 transid)
 399 {
 400         cmd->header.transid =
 401                         cpu_to_le16(transid & KVASER_USB_HYDRA_TRANSID_MASK);
 402 }
 403
 404 static inline u8 kvaser_usb_hydra_get_cmd_src_he(const struct kvaser_cmd *cmd)
 405 {
 406         return (cmd->header.he_addr & KVASER_USB_HYDRA_HE_ADDR_SRC_MASK) >>
 407                 KVASER_USB_HYDRA_HE_ADDR_SRC_BITS |
 408                 le16_to_cpu(cmd->header.transid) >>
 409                 KVASER_USB_HYDRA_TRANSID_BITS;
 410 }
 411
 412 static inline void kvaser_usb_hydra_set_cmd_dest_he(struct kvaser_cmd *cmd,
 413                                                     u8 dest_he)
 414 {
 415         cmd->header.he_addr =
 416                 (cmd->header.he_addr & KVASER_USB_HYDRA_HE_ADDR_SRC_MASK) |
 417                 (dest_he & KVASER_USB_HYDRA_HE_ADDR_DEST_MASK);
 418 }
 419
 420 static u8 kvaser_usb_hydra_channel_from_cmd(const struct kvaser_usb *dev,
 421                                             const struct kvaser_cmd *cmd)
 422 {
 423         int i;
 424         u8 channel = 0xff;
 425         u8 src_he = kvaser_usb_hydra_get_cmd_src_he(cmd);
 426
 427         for (i = 0; i < KVASER_USB_MAX_NET_DEVICES; i++) {
 428                 if (dev->card_data.hydra.channel_to_he[i] == src_he) {
 429                         channel = i;
 430                         break;
 431                 }
 432         }
 433
 434         return channel;
 435 }
 436
 437 static u16 kvaser_usb_hydra_get_next_transid(struct kvaser_usb *dev)
 438 {
 439         unsigned long flags;
 440         u16 transid;
 441         struct kvaser_usb_dev_card_data_hydra *card_data =
 442                                                         &dev->card_data.hydra;
 443
 444         spin_lock_irqsave(&card_data->transid_lock, flags);
 445         transid = card_data->transid;
 446         if (transid >= KVASER_USB_HYDRA_MAX_TRANSID)
 447                 transid = KVASER_USB_HYDRA_MIN_TRANSID;
 448         else
 449                 transid++;
 450         card_data->transid = transid;
 451         spin_unlock_irqrestore(&card_data->transid_lock, flags);
 452
 453         return transid;
 454 }
 455
 456 static size_t kvaser_usb_hydra_cmd_size(struct kvaser_cmd *cmd)
 457 {
 458         size_t ret;
 459
 460         if (cmd->header.cmd_no == CMD_EXTENDED)
 461                 ret = le16_to_cpu(((struct kvaser_cmd_ext *)cmd)->len);
 462         else
 463                 ret = sizeof(struct kvaser_cmd);
 464
 465         return ret;
 466 }
 467
 468 static struct kvaser_usb_net_priv *
 469 kvaser_usb_hydra_net_priv_from_cmd(const struct kvaser_usb *dev,
 470                                    const struct kvaser_cmd *cmd)
 471 {
 472         struct kvaser_usb_net_priv *priv = NULL;
 473         u8 channel = kvaser_usb_hydra_channel_from_cmd(dev, cmd);
 474
 475         if (channel >= dev->nchannels)
 476                 dev_err(&dev->intf->dev,
 477                         "Invalid channel number (%d)\n", channel);
 478         else
 479                 priv = dev->nets[channel];
 480
 481         return priv;
 482 }
 483
 484 static ktime_t
 485 kvaser_usb_hydra_ktime_from_rx_cmd(const struct kvaser_usb_dev_cfg *cfg,
 486                                    const struct kvaser_cmd *cmd)
 487 {
 488         u64 ticks;
 489
 490         if (cmd->header.cmd_no == CMD_EXTENDED) {
 491                 struct kvaser_cmd_ext *cmd_ext = (struct kvaser_cmd_ext *)cmd;
 492
 493                 ticks = le64_to_cpu(cmd_ext->rx_can.timestamp);
 494         } else {
 495                 ticks = le16_to_cpu(cmd->rx_can.timestamp[0]);
 496                 ticks += (u64)(le16_to_cpu(cmd->rx_can.timestamp[1])) << 16;
 497                 ticks += (u64)(le16_to_cpu(cmd->rx_can.timestamp[2])) << 32;
 498         }
 499
 500         return ns_to_ktime(div_u64(ticks * 1000, cfg->timestamp_freq));
 501 }
 502
 503 static int kvaser_usb_hydra_send_simple_cmd(struct kvaser_usb *dev,
 504                                             u8 cmd_no, int channel)
 505 {
 506         struct kvaser_cmd *cmd;
 507         int err;
 508
 509         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
 510         if (!cmd)
 511                 return -ENOMEM;
 512
 513         cmd->header.cmd_no = cmd_no;
 514         if (channel < 0) {
 515                 kvaser_usb_hydra_set_cmd_dest_he
 516                                 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL);
 517         } else {
 518                 if (channel >= KVASER_USB_MAX_NET_DEVICES) {
 519                         dev_err(&dev->intf->dev, "channel (%d) out of range.\n",
 520                                 channel);
 521                         err = -EINVAL;
 522                         goto end;
 523                 }
 524                 kvaser_usb_hydra_set_cmd_dest_he
 525                         (cmd, dev->card_data.hydra.channel_to_he[channel]);
 526         }
 527         kvaser_usb_hydra_set_cmd_transid
 528                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
 529
 530         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
 531         if (err)
 532                 goto end;
 533
 534 end:
 535         kfree(cmd);
 536
 537         return err;
 538 }
 539
 540 static int
 541 kvaser_usb_hydra_send_simple_cmd_async(struct kvaser_usb_net_priv *priv,
 542                                        u8 cmd_no)
 543 {
 544         struct kvaser_cmd *cmd;
 545         struct kvaser_usb *dev = priv->dev;
 546         int err;
 547
 548         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_ATOMIC);
 549         if (!cmd)
 550                 return -ENOMEM;
 551
 552         cmd->header.cmd_no = cmd_no;
 553
 554         kvaser_usb_hydra_set_cmd_dest_he
 555                 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
 556         kvaser_usb_hydra_set_cmd_transid
 557                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
 558
 559         err = kvaser_usb_send_cmd_async(priv, cmd,
 560                                         kvaser_usb_hydra_cmd_size(cmd));
 561         if (err)
 562                 kfree(cmd);
 563
 564         return err;
 565 }
 566
 567 /* This function is used for synchronously waiting on hydra control commands.
 568  * Note: Compared to kvaser_usb_hydra_read_bulk_callback(), we never need to
 569  *       handle partial hydra commands. Since hydra control commands are always
 570  *       non-extended commands.
 571  */
 572 static int kvaser_usb_hydra_wait_cmd(const struct kvaser_usb *dev, u8 cmd_no,
 573                                      struct kvaser_cmd *cmd)
 574 {
 575         void *buf;
 576         int err;
 577         unsigned long timeout = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT);
 578
 579         if (cmd->header.cmd_no == CMD_EXTENDED) {
 580                 dev_err(&dev->intf->dev, "Wait for CMD_EXTENDED not allowed\n");
 581                 return -EINVAL;
 582         }
 583
 584         buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL);
 585         if (!buf)
 586                 return -ENOMEM;
 587
 588         do {
 589                 int actual_len = 0;
 590                 int pos = 0;
 591
 592                 err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE,
 593                                           &actual_len);
 594                 if (err < 0)
 595                         goto end;
 596
 597                 while (pos < actual_len) {
 598                         struct kvaser_cmd *tmp_cmd;
 599                         size_t cmd_len;
 600
 601                         tmp_cmd = buf + pos;
 602                         cmd_len = kvaser_usb_hydra_cmd_size(tmp_cmd);
 603                         if (pos + cmd_len > actual_len) {
 604                                 dev_err_ratelimited(&dev->intf->dev,
 605                                                     "Format error\n");
 606                                 break;
 607                         }
 608
 609                         if (tmp_cmd->header.cmd_no == cmd_no) {
 610                                 memcpy(cmd, tmp_cmd, cmd_len);
 611                                 goto end;
 612                         }
 613                         pos += cmd_len;
 614                 }
 615         } while (time_before(jiffies, timeout));
 616
 617         err = -EINVAL;
 618
 619 end:
 620         kfree(buf);
 621
 622         return err;
 623 }
 624
 625 static int kvaser_usb_hydra_map_channel_resp(struct kvaser_usb *dev,
 626                                              const struct kvaser_cmd *cmd)
 627 {
 628         u8 he, channel;
 629         u16 transid = kvaser_usb_hydra_get_cmd_transid(cmd);
 630         struct kvaser_usb_dev_card_data_hydra *card_data =
 631                                                         &dev->card_data.hydra;
 632
 633         if (transid > 0x007f || transid < 0x0040) {
 634                 dev_err(&dev->intf->dev,
 635                         "CMD_MAP_CHANNEL_RESP, invalid transid: 0x%x\n",
 636                         transid);
 637                 return -EINVAL;
 638         }
 639
 640         switch (transid) {
 641         case KVASER_USB_HYDRA_TRANSID_CANHE:
 642         case KVASER_USB_HYDRA_TRANSID_CANHE + 1:
 643         case KVASER_USB_HYDRA_TRANSID_CANHE + 2:
 644         case KVASER_USB_HYDRA_TRANSID_CANHE + 3:
 645         case KVASER_USB_HYDRA_TRANSID_CANHE + 4:
 646                 channel = transid & 0x000f;
 647                 he = cmd->map_ch_res.he_addr;
 648                 card_data->channel_to_he[channel] = he;
 649                 break;
 650         case KVASER_USB_HYDRA_TRANSID_SYSDBG:
 651                 card_data->sysdbg_he = cmd->map_ch_res.he_addr;
 652                 break;
 653         default:
 654                 dev_warn(&dev->intf->dev,
 655                          "Unknown CMD_MAP_CHANNEL_RESP transid=0x%x\n",
 656                          transid);
 657                 break;
 658         }
 659
 660         return 0;
 661 }
 662
 663 static int kvaser_usb_hydra_map_channel(struct kvaser_usb *dev, u16 transid,
 664                                         u8 channel, const char *name)
 665 {
 666         struct kvaser_cmd *cmd;
 667         int err;
 668
 669         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
 670         if (!cmd)
 671                 return -ENOMEM;
 672
 673         strcpy(cmd->map_ch_req.name, name);
 674         cmd->header.cmd_no = CMD_MAP_CHANNEL_REQ;
 675         kvaser_usb_hydra_set_cmd_dest_he
 676                                 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ROUTER);
 677         cmd->map_ch_req.channel = channel;
 678
 679         kvaser_usb_hydra_set_cmd_transid(cmd, transid);
 680
 681         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
 682         if (err)
 683                 goto end;
 684
 685         err = kvaser_usb_hydra_wait_cmd(dev, CMD_MAP_CHANNEL_RESP, cmd);
 686         if (err)
 687                 goto end;
 688
 689         err = kvaser_usb_hydra_map_channel_resp(dev, cmd);
 690         if (err)
 691                 goto end;
 692
 693 end:
 694         kfree(cmd);
 695
 696         return err;
 697 }
 698
 699 static int kvaser_usb_hydra_get_single_capability(struct kvaser_usb *dev,
 700                                                   u16 cap_cmd_req, u16 *status)
 701 {
 702         struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
 703         struct kvaser_cmd *cmd;
 704         u32 value = 0;
 705         u32 mask = 0;
 706         u16 cap_cmd_res;
 707         int err;
 708         int i;
 709
 710         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
 711         if (!cmd)
 712                 return -ENOMEM;
 713
 714         cmd->header.cmd_no = CMD_GET_CAPABILITIES_REQ;
 715         cmd->cap_req.cap_cmd = cpu_to_le16(cap_cmd_req);
 716
 717         kvaser_usb_hydra_set_cmd_dest_he(cmd, card_data->hydra.sysdbg_he);
 718         kvaser_usb_hydra_set_cmd_transid
 719                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
 720
 721         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
 722         if (err)
 723                 goto end;
 724
 725         err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_CAPABILITIES_RESP, cmd);
 726         if (err)
 727                 goto end;
 728
 729         *status = le16_to_cpu(cmd->cap_res.status);
 730
 731         if (*status != KVASER_USB_HYDRA_CAP_STAT_OK)
 732                 goto end;
 733
 734         cap_cmd_res = le16_to_cpu(cmd->cap_res.cap_cmd);
 735         switch (cap_cmd_res) {
 736         case KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE:
 737         case KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT:
 738         case KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT:
 739                 value = le32_to_cpu(cmd->cap_res.value);
 740                 mask = le32_to_cpu(cmd->cap_res.mask);
 741                 break;
 742         default:
 743                 dev_warn(&dev->intf->dev, "Unknown capability command %u\n",
 744                          cap_cmd_res);
 745                 break;
 746         }
 747
 748         for (i = 0; i < dev->nchannels; i++) {
 749                 if (BIT(i) & (value & mask)) {
 750                         switch (cap_cmd_res) {
 751                         case KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE:
 752                                 card_data->ctrlmode_supported |=
 753                                                 CAN_CTRLMODE_LISTENONLY;
 754                                 break;
 755                         case KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT:
 756                                 card_data->capabilities |=
 757                                                 KVASER_USB_CAP_BERR_CAP;
 758                                 break;
 759                         case KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT:
 760                                 card_data->ctrlmode_supported |=
 761                                                 CAN_CTRLMODE_ONE_SHOT;
 762                                 break;
 763                         }
 764                 }
 765         }
 766
 767 end:
 768         kfree(cmd);
 769
 770         return err;
 771 }
 772
 773 static void kvaser_usb_hydra_start_chip_reply(const struct kvaser_usb *dev,
 774                                               const struct kvaser_cmd *cmd)
 775 {
 776         struct kvaser_usb_net_priv *priv;
 777
 778         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
 779         if (!priv)
 780                 return;
 781
 782         if (completion_done(&priv->start_comp) &&
 783             netif_queue_stopped(priv->netdev)) {
 784                 netif_wake_queue(priv->netdev);
 785         } else {
 786                 netif_start_queue(priv->netdev);
 787                 complete(&priv->start_comp);
 788         }
 789 }
 790
 791 static void kvaser_usb_hydra_stop_chip_reply(const struct kvaser_usb *dev,
 792                                              const struct kvaser_cmd *cmd)
 793 {
 794         struct kvaser_usb_net_priv *priv;
 795
 796         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
 797         if (!priv)
 798                 return;
 799
 800         complete(&priv->stop_comp);
 801 }
 802
 803 static void kvaser_usb_hydra_flush_queue_reply(const struct kvaser_usb *dev,
 804                                                const struct kvaser_cmd *cmd)
 805 {
 806         struct kvaser_usb_net_priv *priv;
 807
 808         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
 809         if (!priv)
 810                 return;
 811
 812         complete(&priv->flush_comp);
 813 }
 814
 815 static void
 816 kvaser_usb_hydra_bus_status_to_can_state(const struct kvaser_usb_net_priv *priv,
 817                                          u8 bus_status,
 818                                          const struct can_berr_counter *bec,
 819                                          enum can_state *new_state)
 820 {
 821         if (bus_status & KVASER_USB_HYDRA_BUS_BUS_OFF) {
 822                 *new_state = CAN_STATE_BUS_OFF;
 823         } else if (bus_status & KVASER_USB_HYDRA_BUS_ERR_PASS) {
 824                 *new_state = CAN_STATE_ERROR_PASSIVE;
 825         } else if (bus_status == KVASER_USB_HYDRA_BUS_ERR_ACT) {
 826                 if (bec->txerr >= 128 || bec->rxerr >= 128) {
 827                         netdev_warn(priv->netdev,
 828                                     "ERR_ACTIVE but err tx=%u or rx=%u >=128\n",
 829                                     bec->txerr, bec->rxerr);
 830                         *new_state = CAN_STATE_ERROR_PASSIVE;
 831                 } else if (bec->txerr >= 96 || bec->rxerr >= 96) {
 832                         *new_state = CAN_STATE_ERROR_WARNING;
 833                 } else {
 834                         *new_state = CAN_STATE_ERROR_ACTIVE;
 835                 }
 836         }
 837 }
 838
 839 static void kvaser_usb_hydra_update_state(struct kvaser_usb_net_priv *priv,
 840                                           u8 bus_status,
 841                                           const struct can_berr_counter *bec)
 842 {
 843         struct net_device *netdev = priv->netdev;
 844         struct can_frame *cf;
 845         struct sk_buff *skb;
 846         struct net_device_stats *stats;
 847         enum can_state new_state, old_state;
 848
 849         old_state = priv->can.state;
 850
 851         kvaser_usb_hydra_bus_status_to_can_state(priv, bus_status, bec,
 852                                                  &new_state);
 853
 854         if (new_state == old_state)
 855                 return;
 856
 857         /* Ignore state change if previous state was STOPPED and the new state
 858          * is BUS_OFF. Firmware always report this as BUS_OFF, since firmware
 859          * does not distinguish between BUS_OFF and STOPPED.
 860          */
 861         if (old_state == CAN_STATE_STOPPED && new_state == CAN_STATE_BUS_OFF)
 862                 return;
 863
 864         skb = alloc_can_err_skb(netdev, &cf);
 865         if (skb) {
 866                 enum can_state tx_state, rx_state;
 867
 868                 tx_state = (bec->txerr >= bec->rxerr) ?
 869                                         new_state : CAN_STATE_ERROR_ACTIVE;
 870                 rx_state = (bec->txerr <= bec->rxerr) ?
 871                                         new_state : CAN_STATE_ERROR_ACTIVE;
 872                 can_change_state(netdev, cf, tx_state, rx_state);
 873         }
 874
 875         if (new_state == CAN_STATE_BUS_OFF && old_state < CAN_STATE_BUS_OFF) {
 876                 if (!priv->can.restart_ms)
 877                         kvaser_usb_hydra_send_simple_cmd_async
 878                                                 (priv, CMD_STOP_CHIP_REQ);
 879
 880                 can_bus_off(netdev);
 881         }
 882
 883         if (!skb) {
 884                 netdev_warn(netdev, "No memory left for err_skb\n");
 885                 return;
 886         }
 887
 888         if (priv->can.restart_ms &&
 889             old_state >= CAN_STATE_BUS_OFF &&
 890             new_state < CAN_STATE_BUS_OFF)
 891                 priv->can.can_stats.restarts++;
 892
 893         cf->data[6] = bec->txerr;
 894         cf->data[7] = bec->rxerr;
 895
 896         stats = &netdev->stats;
 897         stats->rx_packets++;
 898         stats->rx_bytes += cf->can_dlc;
 899         netif_rx(skb);
 900 }
 901
 902 static void kvaser_usb_hydra_state_event(const struct kvaser_usb *dev,
 903                                          const struct kvaser_cmd *cmd)
 904 {
 905         struct kvaser_usb_net_priv *priv;
 906         struct can_berr_counter bec;
 907         u8 bus_status;
 908
 909         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
 910         if (!priv)
 911                 return;
 912
 913         bus_status = cmd->chip_state_event.bus_status;
 914         bec.txerr = cmd->chip_state_event.tx_err_counter;
 915         bec.rxerr = cmd->chip_state_event.rx_err_counter;
 916
 917         kvaser_usb_hydra_update_state(priv, bus_status, &bec);
 918         priv->bec.txerr = bec.txerr;
 919         priv->bec.rxerr = bec.rxerr;
 920 }
 921
 922 static void kvaser_usb_hydra_error_event_parameter(const struct kvaser_usb *dev,
 923                                                    const struct kvaser_cmd *cmd)
 924 {
 925         /* info1 will contain the offending cmd_no */
 926         switch (le16_to_cpu(cmd->error_event.info1)) {
 927         case CMD_START_CHIP_REQ:
 928                 dev_warn(&dev->intf->dev,
 929                          "CMD_START_CHIP_REQ error in parameter\n");
 930                 break;
 931
 932         case CMD_STOP_CHIP_REQ:
 933                 dev_warn(&dev->intf->dev,
 934                          "CMD_STOP_CHIP_REQ error in parameter\n");
 935                 break;
 936
 937         case CMD_FLUSH_QUEUE:
 938                 dev_warn(&dev->intf->dev,
 939                          "CMD_FLUSH_QUEUE error in parameter\n");
 940                 break;
 941
 942         case CMD_SET_BUSPARAMS_REQ:
 943                 dev_warn(&dev->intf->dev,
 944                          "Set bittiming failed. Error in parameter\n");
 945                 break;
 946
 947         case CMD_SET_BUSPARAMS_FD_REQ:
 948                 dev_warn(&dev->intf->dev,
 949                          "Set data bittiming failed. Error in parameter\n");
 950                 break;
 951
 952         default:
 953                 dev_warn(&dev->intf->dev,
 954                          "Unhandled parameter error event cmd_no (%u)\n",
 955                          le16_to_cpu(cmd->error_event.info1));
 956                 break;
 957         }
 958 }
 959
 960 static void kvaser_usb_hydra_error_event(const struct kvaser_usb *dev,
 961                                          const struct kvaser_cmd *cmd)
 962 {
 963         switch (cmd->error_event.error_code) {
 964         case KVASER_USB_HYDRA_ERROR_EVENT_PARAM:
 965                 kvaser_usb_hydra_error_event_parameter(dev, cmd);
 966                 break;
 967
 968         case KVASER_USB_HYDRA_ERROR_EVENT_CAN:
 969                 /* Wrong channel mapping?! This should never happen!
 970                  * info1 will contain the offending cmd_no
 971                  */
 972                 dev_err(&dev->intf->dev,
 973                         "Received CAN error event for cmd_no (%u)\n",
 974                         le16_to_cpu(cmd->error_event.info1));
 975                 break;
 976
 977         default:
 978                 dev_warn(&dev->intf->dev,
 979                          "Unhandled error event (%d)\n",
 980                          cmd->error_event.error_code);
 981                 break;
 982         }
 983 }
 984
 985 static void
 986 kvaser_usb_hydra_error_frame(struct kvaser_usb_net_priv *priv,
 987                              const struct kvaser_err_frame_data *err_frame_data,
 988                              ktime_t hwtstamp)
 989 {
 990         struct net_device *netdev = priv->netdev;
 991         struct net_device_stats *stats = &netdev->stats;
 992         struct can_frame *cf;
 993         struct sk_buff *skb;
 994         struct skb_shared_hwtstamps *shhwtstamps;
 995         struct can_berr_counter bec;
 996         enum can_state new_state, old_state;
 997         u8 bus_status;
 998
 999         priv->can.can_stats.bus_error++;
1000         stats->rx_errors++;
1001
1002         bus_status = err_frame_data->bus_status;
1003         bec.txerr = err_frame_data->tx_err_counter;
1004         bec.rxerr = err_frame_data->rx_err_counter;
1005
1006         old_state = priv->can.state;
1007         kvaser_usb_hydra_bus_status_to_can_state(priv, bus_status, &bec,
1008                                                  &new_state);
1009
1010         skb = alloc_can_err_skb(netdev, &cf);
1011
1012         if (new_state != old_state) {
1013                 if (skb) {
1014                         enum can_state tx_state, rx_state;
1015
1016                         tx_state = (bec.txerr >= bec.rxerr) ?
1017                                         new_state : CAN_STATE_ERROR_ACTIVE;
1018                         rx_state = (bec.txerr <= bec.rxerr) ?
1019                                         new_state : CAN_STATE_ERROR_ACTIVE;
1020
1021                         can_change_state(netdev, cf, tx_state, rx_state);
1022
1023                         if (priv->can.restart_ms &&
1024                             old_state >= CAN_STATE_BUS_OFF &&
1025                             new_state < CAN_STATE_BUS_OFF)
1026                                 cf->can_id |= CAN_ERR_RESTARTED;
1027                 }
1028
1029                 if (new_state == CAN_STATE_BUS_OFF) {
1030                         if (!priv->can.restart_ms)
1031                                 kvaser_usb_hydra_send_simple_cmd_async
1032                                                 (priv, CMD_STOP_CHIP_REQ);
1033
1034                         can_bus_off(netdev);
1035                 }
1036         }
1037
1038         if (!skb) {
1039                 stats->rx_dropped++;
1040                 netdev_warn(netdev, "No memory left for err_skb\n");
1041                 return;
1042         }
1043
1044         shhwtstamps = skb_hwtstamps(skb);
1045         shhwtstamps->hwtstamp = hwtstamp;
1046
1047         cf->can_id |= CAN_ERR_BUSERROR;
1048         cf->data[6] = bec.txerr;
1049         cf->data[7] = bec.rxerr;
1050
1051         stats->rx_packets++;
1052         stats->rx_bytes += cf->can_dlc;
1053         netif_rx(skb);
1054
1055         priv->bec.txerr = bec.txerr;
1056         priv->bec.rxerr = bec.rxerr;
1057 }
1058
1059 static void kvaser_usb_hydra_one_shot_fail(struct kvaser_usb_net_priv *priv,
1060                                            const struct kvaser_cmd_ext *cmd)
1061 {
1062         struct net_device *netdev = priv->netdev;
1063         struct net_device_stats *stats = &netdev->stats;
1064         struct can_frame *cf;
1065         struct sk_buff *skb;
1066         u32 flags;
1067
1068         skb = alloc_can_err_skb(netdev, &cf);
1069         if (!skb) {
1070                 stats->rx_dropped++;
1071                 netdev_warn(netdev, "No memory left for err_skb\n");
1072                 return;
1073         }
1074
1075         cf->can_id |= CAN_ERR_BUSERROR;
1076         flags = le32_to_cpu(cmd->tx_ack.flags);
1077
1078         if (flags & KVASER_USB_HYDRA_CF_FLAG_OSM_NACK)
1079                 cf->can_id |= CAN_ERR_ACK;
1080         if (flags & KVASER_USB_HYDRA_CF_FLAG_ABL) {
1081                 cf->can_id |= CAN_ERR_LOSTARB;
1082                 priv->can.can_stats.arbitration_lost++;
1083         }
1084
1085         stats->tx_errors++;
1086         stats->rx_packets++;
1087         stats->rx_bytes += cf->can_dlc;
1088         netif_rx(skb);
1089 }
1090
1091 static void kvaser_usb_hydra_tx_acknowledge(const struct kvaser_usb *dev,
1092                                             const struct kvaser_cmd *cmd)
1093 {
1094         struct kvaser_usb_tx_urb_context *context;
1095         struct kvaser_usb_net_priv *priv;
1096         unsigned long irq_flags;
1097         bool one_shot_fail = false;
1098         u16 transid = kvaser_usb_hydra_get_cmd_transid(cmd);
1099
1100         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
1101         if (!priv)
1102                 return;
1103
1104         if (!netif_device_present(priv->netdev))
1105                 return;
1106
1107         if (cmd->header.cmd_no == CMD_EXTENDED) {
1108                 struct kvaser_cmd_ext *cmd_ext = (struct kvaser_cmd_ext *)cmd;
1109                 u32 flags = le32_to_cpu(cmd_ext->tx_ack.flags);
1110
1111                 if (flags & (KVASER_USB_HYDRA_CF_FLAG_OSM_NACK |
1112                              KVASER_USB_HYDRA_CF_FLAG_ABL)) {
1113                         kvaser_usb_hydra_one_shot_fail(priv, cmd_ext);
1114                         one_shot_fail = true;
1115                 }
1116         }
1117
1118         context = &priv->tx_contexts[transid % dev->max_tx_urbs];
1119         if (!one_shot_fail) {
1120                 struct net_device_stats *stats = &priv->netdev->stats;
1121
1122                 stats->tx_packets++;
1123                 stats->tx_bytes += can_dlc2len(context->dlc);
1124         }
1125
1126         spin_lock_irqsave(&priv->tx_contexts_lock, irq_flags);
1127
1128         can_get_echo_skb(priv->netdev, context->echo_index);
1129         context->echo_index = dev->max_tx_urbs;
1130         --priv->active_tx_contexts;
1131         netif_wake_queue(priv->netdev);
1132
1133         spin_unlock_irqrestore(&priv->tx_contexts_lock, irq_flags);
1134 }
1135
1136 static void kvaser_usb_hydra_rx_msg_std(const struct kvaser_usb *dev,
1137                                         const struct kvaser_cmd *cmd)
1138 {
1139         struct kvaser_usb_net_priv *priv = NULL;
1140         struct can_frame *cf;
1141         struct sk_buff *skb;
1142         struct skb_shared_hwtstamps *shhwtstamps;
1143         struct net_device_stats *stats;
1144         u8 flags;
1145         ktime_t hwtstamp;
1146
1147         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
1148         if (!priv)
1149                 return;
1150
1151         stats = &priv->netdev->stats;
1152
1153         flags = cmd->rx_can.flags;
1154         hwtstamp = kvaser_usb_hydra_ktime_from_rx_cmd(dev->cfg, cmd);
1155
1156         if (flags & KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME) {
1157                 kvaser_usb_hydra_error_frame(priv, &cmd->rx_can.err_frame_data,
1158                                              hwtstamp);
1159                 return;
1160         }
1161
1162         skb = alloc_can_skb(priv->netdev, &cf);
1163         if (!skb) {
1164                 stats->rx_dropped++;
1165                 return;
1166         }
1167
1168         shhwtstamps = skb_hwtstamps(skb);
1169         shhwtstamps->hwtstamp = hwtstamp;
1170
1171         cf->can_id = le32_to_cpu(cmd->rx_can.id);
1172
1173         if (cf->can_id &  KVASER_USB_HYDRA_EXTENDED_FRAME_ID) {
1174                 cf->can_id &= CAN_EFF_MASK;
1175                 cf->can_id |= CAN_EFF_FLAG;
1176         } else {
1177                 cf->can_id &= CAN_SFF_MASK;
1178         }
1179
1180         if (flags & KVASER_USB_HYDRA_CF_FLAG_OVERRUN)
1181                 kvaser_usb_can_rx_over_error(priv->netdev);
1182
1183         cf->can_dlc = get_can_dlc(cmd->rx_can.dlc);
1184
1185         if (flags & KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME)
1186                 cf->can_id |= CAN_RTR_FLAG;
1187         else
1188                 memcpy(cf->data, cmd->rx_can.data, cf->can_dlc);
1189
1190         stats->rx_packets++;
1191         stats->rx_bytes += cf->can_dlc;
1192         netif_rx(skb);
1193 }
1194
1195 static void kvaser_usb_hydra_rx_msg_ext(const struct kvaser_usb *dev,
1196                                         const struct kvaser_cmd_ext *cmd)
1197 {
1198         struct kvaser_cmd *std_cmd = (struct kvaser_cmd *)cmd;
1199         struct kvaser_usb_net_priv *priv;
1200         struct canfd_frame *cf;
1201         struct sk_buff *skb;
1202         struct skb_shared_hwtstamps *shhwtstamps;
1203         struct net_device_stats *stats;
1204         u32 flags;
1205         u8 dlc;
1206         u32 kcan_header;
1207         ktime_t hwtstamp;
1208
1209         priv = kvaser_usb_hydra_net_priv_from_cmd(dev, std_cmd);
1210         if (!priv)
1211                 return;
1212
1213         stats = &priv->netdev->stats;
1214
1215         kcan_header = le32_to_cpu(cmd->rx_can.kcan_header);
1216         dlc = (kcan_header & KVASER_USB_KCAN_DATA_DLC_MASK) >>
1217                 KVASER_USB_KCAN_DATA_DLC_SHIFT;
1218
1219         flags = le32_to_cpu(cmd->rx_can.flags);
1220         hwtstamp = kvaser_usb_hydra_ktime_from_rx_cmd(dev->cfg, std_cmd);
1221
1222         if (flags & KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME) {
1223                 kvaser_usb_hydra_error_frame(priv, &cmd->rx_can.err_frame_data,
1224                                              hwtstamp);
1225                 return;
1226         }
1227
1228         if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF)
1229                 skb = alloc_canfd_skb(priv->netdev, &cf);
1230         else
1231                 skb = alloc_can_skb(priv->netdev, (struct can_frame **)&cf);
1232
1233         if (!skb) {
1234                 stats->rx_dropped++;
1235                 return;
1236         }
1237
1238         shhwtstamps = skb_hwtstamps(skb);
1239         shhwtstamps->hwtstamp = hwtstamp;
1240
1241         cf->can_id = le32_to_cpu(cmd->rx_can.id);
1242
1243         if (flags & KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID) {
1244                 cf->can_id &= CAN_EFF_MASK;
1245                 cf->can_id |= CAN_EFF_FLAG;
1246         } else {
1247                 cf->can_id &= CAN_SFF_MASK;
1248         }
1249
1250         if (flags & KVASER_USB_HYDRA_CF_FLAG_OVERRUN)
1251                 kvaser_usb_can_rx_over_error(priv->netdev);
1252
1253         if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF) {
1254                 cf->len = can_dlc2len(get_canfd_dlc(dlc));
1255                 if (flags & KVASER_USB_HYDRA_CF_FLAG_BRS)
1256                         cf->flags |= CANFD_BRS;
1257                 if (flags & KVASER_USB_HYDRA_CF_FLAG_ESI)
1258                         cf->flags |= CANFD_ESI;
1259         } else {
1260                 cf->len = get_can_dlc(dlc);
1261         }
1262
1263         if (flags & KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME)
1264                 cf->can_id |= CAN_RTR_FLAG;
1265         else
1266                 memcpy(cf->data, cmd->rx_can.kcan_payload, cf->len);
1267
1268         stats->rx_packets++;
1269         stats->rx_bytes += cf->len;
1270         netif_rx(skb);
1271 }
1272
1273 static void kvaser_usb_hydra_handle_cmd_std(const struct kvaser_usb *dev,
1274                                             const struct kvaser_cmd *cmd)
1275 {
1276         switch (cmd->header.cmd_no) {
1277         case CMD_START_CHIP_RESP:
1278                 kvaser_usb_hydra_start_chip_reply(dev, cmd);
1279                 break;
1280
1281         case CMD_STOP_CHIP_RESP:
1282                 kvaser_usb_hydra_stop_chip_reply(dev, cmd);
1283                 break;
1284
1285         case CMD_FLUSH_QUEUE_RESP:
1286                 kvaser_usb_hydra_flush_queue_reply(dev, cmd);
1287                 break;
1288
1289         case CMD_CHIP_STATE_EVENT:
1290                 kvaser_usb_hydra_state_event(dev, cmd);
1291                 break;
1292
1293         case CMD_ERROR_EVENT:
1294                 kvaser_usb_hydra_error_event(dev, cmd);
1295                 break;
1296
1297         case CMD_TX_ACKNOWLEDGE:
1298                 kvaser_usb_hydra_tx_acknowledge(dev, cmd);
1299                 break;
1300
1301         case CMD_RX_MESSAGE:
1302                 kvaser_usb_hydra_rx_msg_std(dev, cmd);
1303                 break;
1304
1305         /* Ignored commands */
1306         case CMD_SET_BUSPARAMS_RESP:
1307         case CMD_SET_BUSPARAMS_FD_RESP:
1308                 break;
1309
1310         default:
1311                 dev_warn(&dev->intf->dev, "Unhandled command (%d)\n",
1312                          cmd->header.cmd_no);
1313                 break;
1314         }
1315 }
1316
1317 static void kvaser_usb_hydra_handle_cmd_ext(const struct kvaser_usb *dev,
1318                                             const struct kvaser_cmd_ext *cmd)
1319 {
1320         switch (cmd->cmd_no_ext) {
1321         case CMD_TX_ACKNOWLEDGE_FD:
1322                 kvaser_usb_hydra_tx_acknowledge(dev, (struct kvaser_cmd *)cmd);
1323                 break;
1324
1325         case CMD_RX_MESSAGE_FD:
1326                 kvaser_usb_hydra_rx_msg_ext(dev, cmd);
1327                 break;
1328
1329         default:
1330                 dev_warn(&dev->intf->dev, "Unhandled extended command (%d)\n",
1331                          cmd->header.cmd_no);
1332                 break;
1333         }
1334 }
1335
1336 static void kvaser_usb_hydra_handle_cmd(const struct kvaser_usb *dev,
1337                                         const struct kvaser_cmd *cmd)
1338 {
1339                 if (cmd->header.cmd_no == CMD_EXTENDED)
1340                         kvaser_usb_hydra_handle_cmd_ext
1341                                         (dev, (struct kvaser_cmd_ext *)cmd);
1342                 else
1343                         kvaser_usb_hydra_handle_cmd_std(dev, cmd);
1344 }
1345
1346 static void *
1347 kvaser_usb_hydra_frame_to_cmd_ext(const struct kvaser_usb_net_priv *priv,
1348                                   const struct sk_buff *skb, int *frame_len,
1349                                   int *cmd_len, u16 transid)
1350 {
1351         struct kvaser_usb *dev = priv->dev;
1352         struct kvaser_cmd_ext *cmd;
1353         struct canfd_frame *cf = (struct canfd_frame *)skb->data;
1354         u8 dlc = can_len2dlc(cf->len);
1355         u8 nbr_of_bytes = cf->len;
1356         u32 flags;
1357         u32 id;
1358         u32 kcan_id;
1359         u32 kcan_header;
1360
1361         *frame_len = nbr_of_bytes;
1362
1363         cmd = kcalloc(1, sizeof(struct kvaser_cmd_ext), GFP_ATOMIC);
1364         if (!cmd)
1365                 return NULL;
1366
1367         kvaser_usb_hydra_set_cmd_dest_he
1368                         ((struct kvaser_cmd *)cmd,
1369                          dev->card_data.hydra.channel_to_he[priv->channel]);
1370         kvaser_usb_hydra_set_cmd_transid((struct kvaser_cmd *)cmd, transid);
1371
1372         cmd->header.cmd_no = CMD_EXTENDED;
1373         cmd->cmd_no_ext = CMD_TX_CAN_MESSAGE_FD;
1374
1375         *cmd_len = ALIGN(sizeof(struct kvaser_cmd_ext) -
1376                          sizeof(cmd->tx_can.kcan_payload) + nbr_of_bytes,
1377                          8);
1378
1379         cmd->len = cpu_to_le16(*cmd_len);
1380
1381         cmd->tx_can.databytes = nbr_of_bytes;
1382         cmd->tx_can.dlc = dlc;
1383
1384         if (cf->can_id & CAN_EFF_FLAG) {
1385                 id = cf->can_id & CAN_EFF_MASK;
1386                 flags = KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID;
1387                 kcan_id = (cf->can_id & CAN_EFF_MASK) |
1388                           KVASER_USB_KCAN_DATA_IDE | KVASER_USB_KCAN_DATA_SRR;
1389         } else {
1390                 id = cf->can_id & CAN_SFF_MASK;
1391                 flags = 0;
1392                 kcan_id = cf->can_id & CAN_SFF_MASK;
1393         }
1394
1395         if (cf->can_id & CAN_ERR_FLAG)
1396                 flags |= KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME;
1397
1398         kcan_header = ((dlc << KVASER_USB_KCAN_DATA_DLC_SHIFT) &
1399                                 KVASER_USB_KCAN_DATA_DLC_MASK) |
1400                         KVASER_USB_KCAN_DATA_AREQ |
1401                         (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT ?
1402                                 KVASER_USB_KCAN_DATA_OSM : 0);
1403
1404         if (can_is_canfd_skb(skb)) {
1405                 kcan_header |= KVASER_USB_KCAN_DATA_FDF |
1406                                (cf->flags & CANFD_BRS ?
1407                                         KVASER_USB_KCAN_DATA_BRS : 0);
1408         } else {
1409                 if (cf->can_id & CAN_RTR_FLAG) {
1410                         kcan_id |= KVASER_USB_KCAN_DATA_RTR;
1411                         cmd->tx_can.databytes = 0;
1412                         flags |= KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME;
1413                 }
1414         }
1415
1416         cmd->tx_can.kcan_id = cpu_to_le32(kcan_id);
1417         cmd->tx_can.id = cpu_to_le32(id);
1418         cmd->tx_can.flags = cpu_to_le32(flags);
1419         cmd->tx_can.kcan_header = cpu_to_le32(kcan_header);
1420
1421         memcpy(cmd->tx_can.kcan_payload, cf->data, nbr_of_bytes);
1422
1423         return cmd;
1424 }
1425
1426 static void *
1427 kvaser_usb_hydra_frame_to_cmd_std(const struct kvaser_usb_net_priv *priv,
1428                                   const struct sk_buff *skb, int *frame_len,
1429                                   int *cmd_len, u16 transid)
1430 {
1431         struct kvaser_usb *dev = priv->dev;
1432         struct kvaser_cmd *cmd;
1433         struct can_frame *cf = (struct can_frame *)skb->data;
1434         u32 flags;
1435         u32 id;
1436
1437         *frame_len = cf->can_dlc;
1438
1439         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_ATOMIC);
1440         if (!cmd)
1441                 return NULL;
1442
1443         kvaser_usb_hydra_set_cmd_dest_he
1444                 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1445         kvaser_usb_hydra_set_cmd_transid(cmd, transid);
1446
1447         cmd->header.cmd_no = CMD_TX_CAN_MESSAGE;
1448
1449         *cmd_len = ALIGN(sizeof(struct kvaser_cmd), 8);
1450
1451         if (cf->can_id & CAN_EFF_FLAG) {
1452                 id = (cf->can_id & CAN_EFF_MASK);
1453                 id |= KVASER_USB_HYDRA_EXTENDED_FRAME_ID;
1454         } else {
1455                 id = cf->can_id & CAN_SFF_MASK;
1456         }
1457
1458         cmd->tx_can.dlc = cf->can_dlc;
1459
1460         flags = (cf->can_id & CAN_EFF_FLAG ?
1461                  KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID : 0);
1462
1463         if (cf->can_id & CAN_RTR_FLAG)
1464                 flags |= KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME;
1465
1466         flags |= (cf->can_id & CAN_ERR_FLAG ?
1467                   KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME : 0);
1468
1469         cmd->tx_can.id = cpu_to_le32(id);
1470         cmd->tx_can.flags = flags;
1471
1472         memcpy(cmd->tx_can.data, cf->data, *frame_len);
1473
1474         return cmd;
1475 }
1476
1477 static int kvaser_usb_hydra_set_mode(struct net_device *netdev,
1478                                      enum can_mode mode)
1479 {
1480         int err = 0;
1481
1482         switch (mode) {
1483         case CAN_MODE_START:
1484                 /* CAN controller automatically recovers from BUS_OFF */
1485                 break;
1486         default:
1487                 err = -EOPNOTSUPP;
1488         }
1489
1490         return err;
1491 }
1492
1493 static int kvaser_usb_hydra_set_bittiming(struct net_device *netdev)
1494 {
1495         struct kvaser_cmd *cmd;
1496         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1497         struct can_bittiming *bt = &priv->can.bittiming;
1498         struct kvaser_usb *dev = priv->dev;
1499         int tseg1 = bt->prop_seg + bt->phase_seg1;
1500         int tseg2 = bt->phase_seg2;
1501         int sjw = bt->sjw;
1502         int err;
1503
1504         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1505         if (!cmd)
1506                 return -ENOMEM;
1507
1508         cmd->header.cmd_no = CMD_SET_BUSPARAMS_REQ;
1509         cmd->set_busparams_req.bitrate = cpu_to_le32(bt->bitrate);
1510         cmd->set_busparams_req.sjw = (u8)sjw;
1511         cmd->set_busparams_req.tseg1 = (u8)tseg1;
1512         cmd->set_busparams_req.tseg2 = (u8)tseg2;
1513         cmd->set_busparams_req.nsamples = 1;
1514
1515         kvaser_usb_hydra_set_cmd_dest_he
1516                 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1517         kvaser_usb_hydra_set_cmd_transid
1518                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1519
1520         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1521
1522         kfree(cmd);
1523
1524         return err;
1525 }
1526
1527 static int kvaser_usb_hydra_set_data_bittiming(struct net_device *netdev)
1528 {
1529         struct kvaser_cmd *cmd;
1530         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1531         struct can_bittiming *dbt = &priv->can.data_bittiming;
1532         struct kvaser_usb *dev = priv->dev;
1533         int tseg1 = dbt->prop_seg + dbt->phase_seg1;
1534         int tseg2 = dbt->phase_seg2;
1535         int sjw = dbt->sjw;
1536         int err;
1537
1538         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1539         if (!cmd)
1540                 return -ENOMEM;
1541
1542         cmd->header.cmd_no = CMD_SET_BUSPARAMS_FD_REQ;
1543         cmd->set_busparams_req.bitrate_d = cpu_to_le32(dbt->bitrate);
1544         cmd->set_busparams_req.sjw_d = (u8)sjw;
1545         cmd->set_busparams_req.tseg1_d = (u8)tseg1;
1546         cmd->set_busparams_req.tseg2_d = (u8)tseg2;
1547         cmd->set_busparams_req.nsamples_d = 1;
1548
1549         if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1550                 if (priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)
1551                         cmd->set_busparams_req.canfd_mode =
1552                                         KVASER_USB_HYDRA_BUS_MODE_NONISO;
1553                 else
1554                         cmd->set_busparams_req.canfd_mode =
1555                                         KVASER_USB_HYDRA_BUS_MODE_CANFD_ISO;
1556         }
1557
1558         kvaser_usb_hydra_set_cmd_dest_he
1559                 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1560         kvaser_usb_hydra_set_cmd_transid
1561                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1562
1563         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1564
1565         kfree(cmd);
1566
1567         return err;
1568 }
1569
1570 static int kvaser_usb_hydra_get_berr_counter(const struct net_device *netdev,
1571                                              struct can_berr_counter *bec)
1572 {
1573         struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1574         int err;
1575
1576         err = kvaser_usb_hydra_send_simple_cmd(priv->dev,
1577                                                CMD_GET_CHIP_STATE_REQ,
1578                                                priv->channel);
1579         if (err)
1580                 return err;
1581
1582         *bec = priv->bec;
1583
1584         return 0;
1585 }
1586
1587 static int kvaser_usb_hydra_setup_endpoints(struct kvaser_usb *dev)
1588 {
1589         const struct usb_host_interface *iface_desc;
1590         struct usb_endpoint_descriptor *ep;
1591         int i;
1592
1593         iface_desc = &dev->intf->altsetting[0];
1594
1595         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1596                 ep = &iface_desc->endpoint[i].desc;
1597
1598                 if (!dev->bulk_in && usb_endpoint_is_bulk_in(ep) &&
1599                     ep->bEndpointAddress == KVASER_USB_HYDRA_BULK_EP_IN_ADDR)
1600                         dev->bulk_in = ep;
1601
1602                 if (!dev->bulk_out && usb_endpoint_is_bulk_out(ep) &&
1603                     ep->bEndpointAddress == KVASER_USB_HYDRA_BULK_EP_OUT_ADDR)
1604                         dev->bulk_out = ep;
1605
1606                 if (dev->bulk_in && dev->bulk_out)
1607                         return 0;
1608         }
1609
1610         return -ENODEV;
1611 }
1612
1613 static int kvaser_usb_hydra_init_card(struct kvaser_usb *dev)
1614 {
1615         int err;
1616         unsigned int i;
1617         struct kvaser_usb_dev_card_data_hydra *card_data =
1618                                                         &dev->card_data.hydra;
1619
1620         card_data->transid = KVASER_USB_HYDRA_MIN_TRANSID;
1621         spin_lock_init(&card_data->transid_lock);
1622
1623         memset(card_data->usb_rx_leftover, 0, KVASER_USB_HYDRA_MAX_CMD_LEN);
1624         card_data->usb_rx_leftover_len = 0;
1625         spin_lock_init(&card_data->usb_rx_leftover_lock);
1626
1627         memset(card_data->channel_to_he, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL,
1628                sizeof(card_data->channel_to_he));
1629         card_data->sysdbg_he = 0;
1630
1631         for (i = 0; i < KVASER_USB_MAX_NET_DEVICES; i++) {
1632                 err = kvaser_usb_hydra_map_channel
1633                                         (dev,
1634                                          (KVASER_USB_HYDRA_TRANSID_CANHE | i),
1635                                          i, "CAN");
1636                 if (err) {
1637                         dev_err(&dev->intf->dev,
1638                                 "CMD_MAP_CHANNEL_REQ failed for CAN%u\n", i);
1639                         return err;
1640                 }
1641         }
1642
1643         err = kvaser_usb_hydra_map_channel(dev, KVASER_USB_HYDRA_TRANSID_SYSDBG,
1644                                            0, "SYSDBG");
1645         if (err) {
1646                 dev_err(&dev->intf->dev,
1647                         "CMD_MAP_CHANNEL_REQ failed for SYSDBG\n");
1648                 return err;
1649         }
1650
1651         return 0;
1652 }
1653
1654 static int kvaser_usb_hydra_get_software_info(struct kvaser_usb *dev)
1655 {
1656         struct kvaser_cmd cmd;
1657         int err;
1658
1659         err = kvaser_usb_hydra_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO_REQ,
1660                                                -1);
1661         if (err)
1662                 return err;
1663
1664         memset(&cmd, 0, sizeof(struct kvaser_cmd));
1665         err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_RESP, &cmd);
1666         if (err)
1667                 return err;
1668
1669         dev->max_tx_urbs = min_t(unsigned int, KVASER_USB_MAX_TX_URBS,
1670                                  le16_to_cpu(cmd.sw_info.max_outstanding_tx));
1671
1672         return 0;
1673 }
1674
1675 static int kvaser_usb_hydra_get_software_details(struct kvaser_usb *dev)
1676 {
1677         struct kvaser_cmd *cmd;
1678         int err;
1679         u32 flags;
1680         struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
1681
1682         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1683         if (!cmd)
1684                 return -ENOMEM;
1685
1686         cmd->header.cmd_no = CMD_GET_SOFTWARE_DETAILS_REQ;
1687         cmd->sw_detail_req.use_ext_cmd = 1;
1688         kvaser_usb_hydra_set_cmd_dest_he
1689                                 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL);
1690
1691         kvaser_usb_hydra_set_cmd_transid
1692                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1693
1694         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1695         if (err)
1696                 goto end;
1697
1698         err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_SOFTWARE_DETAILS_RESP,
1699                                         cmd);
1700         if (err)
1701                 goto end;
1702
1703         dev->fw_version = le32_to_cpu(cmd->sw_detail_res.sw_version);
1704         flags = le32_to_cpu(cmd->sw_detail_res.sw_flags);
1705
1706         if (flags & KVASER_USB_HYDRA_SW_FLAG_FW_BAD) {
1707                 dev_err(&dev->intf->dev,
1708                         "Bad firmware, device refuse to run!\n");
1709                 err = -EINVAL;
1710                 goto end;
1711         }
1712
1713         if (flags & KVASER_USB_HYDRA_SW_FLAG_FW_BETA)
1714                 dev_info(&dev->intf->dev, "Beta firmware in use\n");
1715
1716         if (flags & KVASER_USB_HYDRA_SW_FLAG_EXT_CAP)
1717                 card_data->capabilities |= KVASER_USB_CAP_EXT_CAP;
1718
1719         if (flags & KVASER_USB_HYDRA_SW_FLAG_EXT_CMD)
1720                 card_data->capabilities |= KVASER_USB_HYDRA_CAP_EXT_CMD;
1721
1722         if (flags & KVASER_USB_HYDRA_SW_FLAG_CANFD)
1723                 card_data->ctrlmode_supported |= CAN_CTRLMODE_FD;
1724
1725         if (flags & KVASER_USB_HYDRA_SW_FLAG_NONISO)
1726                 card_data->ctrlmode_supported |= CAN_CTRLMODE_FD_NON_ISO;
1727
1728         if (flags &  KVASER_USB_HYDRA_SW_FLAG_FREQ_80M)
1729                 dev->cfg = &kvaser_usb_hydra_dev_cfg_kcan;
1730         else
1731                 dev->cfg = &kvaser_usb_hydra_dev_cfg_flexc;
1732
1733 end:
1734         kfree(cmd);
1735
1736         return err;
1737 }
1738
1739 static int kvaser_usb_hydra_get_card_info(struct kvaser_usb *dev)
1740 {
1741         struct kvaser_cmd cmd;
1742         int err;
1743
1744         err = kvaser_usb_hydra_send_simple_cmd(dev, CMD_GET_CARD_INFO_REQ, -1);
1745         if (err)
1746                 return err;
1747
1748         memset(&cmd, 0, sizeof(struct kvaser_cmd));
1749         err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_CARD_INFO_RESP, &cmd);
1750         if (err)
1751                 return err;
1752
1753         dev->nchannels = cmd.card_info.nchannels;
1754         if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES)
1755                 return -EINVAL;
1756
1757         return 0;
1758 }
1759
1760 static int kvaser_usb_hydra_get_capabilities(struct kvaser_usb *dev)
1761 {
1762         int err;
1763         u16 status;
1764
1765         if (!(dev->card_data.capabilities & KVASER_USB_CAP_EXT_CAP)) {
1766                 dev_info(&dev->intf->dev,
1767                          "No extended capability support. Upgrade your device.\n");
1768                 return 0;
1769         }
1770
1771         err = kvaser_usb_hydra_get_single_capability
1772                                         (dev,
1773                                          KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE,
1774                                          &status);
1775         if (err)
1776                 return err;
1777         if (status)
1778                 dev_info(&dev->intf->dev,
1779                          "KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE failed %u\n",
1780                          status);
1781
1782         err = kvaser_usb_hydra_get_single_capability
1783                                         (dev,
1784                                          KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT,
1785                                          &status);
1786         if (err)
1787                 return err;
1788         if (status)
1789                 dev_info(&dev->intf->dev,
1790                          "KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT failed %u\n",
1791                          status);
1792
1793         err = kvaser_usb_hydra_get_single_capability
1794                                         (dev, KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT,
1795                                          &status);
1796         if (err)
1797                 return err;
1798         if (status)
1799                 dev_info(&dev->intf->dev,
1800                          "KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT failed %u\n",
1801                          status);
1802
1803         return 0;
1804 }
1805
1806 static int kvaser_usb_hydra_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1807 {
1808         struct kvaser_usb *dev = priv->dev;
1809         struct kvaser_cmd *cmd;
1810         int err;
1811
1812         if ((priv->can.ctrlmode &
1813             (CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO)) ==
1814             CAN_CTRLMODE_FD_NON_ISO) {
1815                 netdev_warn(priv->netdev,
1816                             "CTRLMODE_FD shall be on if CTRLMODE_FD_NON_ISO is on\n");
1817                 return -EINVAL;
1818         }
1819
1820         cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1821         if (!cmd)
1822                 return -ENOMEM;
1823
1824         cmd->header.cmd_no = CMD_SET_DRIVERMODE_REQ;
1825         kvaser_usb_hydra_set_cmd_dest_he
1826                 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1827         kvaser_usb_hydra_set_cmd_transid
1828                                 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1829         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1830                 cmd->set_ctrlmode.mode = KVASER_USB_HYDRA_CTRLMODE_LISTEN;
1831         else
1832                 cmd->set_ctrlmode.mode = KVASER_USB_HYDRA_CTRLMODE_NORMAL;
1833
1834         err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1835         kfree(cmd);
1836
1837         return err;
1838 }
1839
1840 static int kvaser_usb_hydra_start_chip(struct kvaser_usb_net_priv *priv)
1841 {
1842         int err;
1843
1844         init_completion(&priv->start_comp);
1845
1846         err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_START_CHIP_REQ,
1847                                                priv->channel);
1848         if (err)
1849                 return err;
1850
1851         if (!wait_for_completion_timeout(&priv->start_comp,
1852                                          msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1853                 return -ETIMEDOUT;
1854
1855         return 0;
1856 }
1857
1858 static int kvaser_usb_hydra_stop_chip(struct kvaser_usb_net_priv *priv)
1859 {
1860         int err;
1861
1862         init_completion(&priv->stop_comp);
1863
1864         /* Make sure we do not report invalid BUS_OFF from CMD_CHIP_STATE_EVENT
1865          * see comment in kvaser_usb_hydra_update_state()
1866          */
1867         priv->can.state = CAN_STATE_STOPPED;
1868
1869         err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_STOP_CHIP_REQ,
1870                                                priv->channel);
1871         if (err)
1872                 return err;
1873
1874         if (!wait_for_completion_timeout(&priv->stop_comp,
1875                                          msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1876                 return -ETIMEDOUT;
1877
1878         return 0;
1879 }
1880
1881 static int kvaser_usb_hydra_flush_queue(struct kvaser_usb_net_priv *priv)
1882 {
1883         int err;
1884
1885         init_completion(&priv->flush_comp);
1886
1887         err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_FLUSH_QUEUE,
1888                                                priv->channel);
1889         if (err)
1890                 return err;
1891
1892         if (!wait_for_completion_timeout(&priv->flush_comp,
1893                                          msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1894                 return -ETIMEDOUT;
1895
1896         return 0;
1897 }
1898
1899 /* A single extended hydra command can be transmitted in multiple transfers
1900  * We have to buffer partial hydra commands, and handle them on next callback.
1901  */
1902 static void kvaser_usb_hydra_read_bulk_callback(struct kvaser_usb *dev,
1903                                                 void *buf, int len)
1904 {
1905         unsigned long irq_flags;
1906         struct kvaser_cmd *cmd;
1907         int pos = 0;
1908         size_t cmd_len;
1909         struct kvaser_usb_dev_card_data_hydra *card_data =
1910                                                         &dev->card_data.hydra;
1911         int usb_rx_leftover_len;
1912         spinlock_t *usb_rx_leftover_lock = &card_data->usb_rx_leftover_lock;
1913
1914         spin_lock_irqsave(usb_rx_leftover_lock, irq_flags);
1915         usb_rx_leftover_len = card_data->usb_rx_leftover_len;
1916         if (usb_rx_leftover_len) {
1917                 int remaining_bytes;
1918
1919                 cmd = (struct kvaser_cmd *)card_data->usb_rx_leftover;
1920
1921                 cmd_len = kvaser_usb_hydra_cmd_size(cmd);
1922
1923                 remaining_bytes = min_t(unsigned int, len,
1924                                         cmd_len - usb_rx_leftover_len);
1925                 /* Make sure we do not overflow usb_rx_leftover */
1926                 if (remaining_bytes + usb_rx_leftover_len >
1927                                                 KVASER_USB_HYDRA_MAX_CMD_LEN) {
1928                         dev_err(&dev->intf->dev, "Format error\n");
1929                         spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags);
1930                         return;
1931                 }
1932
1933                 memcpy(card_data->usb_rx_leftover + usb_rx_leftover_len, buf,
1934                        remaining_bytes);
1935                 pos += remaining_bytes;
1936
1937                 if (remaining_bytes + usb_rx_leftover_len == cmd_len) {
1938                         kvaser_usb_hydra_handle_cmd(dev, cmd);
1939                         usb_rx_leftover_len = 0;
1940                 } else {
1941                         /* Command still not complete */
1942                         usb_rx_leftover_len += remaining_bytes;
1943                 }
1944                 card_data->usb_rx_leftover_len = usb_rx_leftover_len;
1945         }
1946         spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags);
1947
1948         while (pos < len) {
1949                 cmd = buf + pos;
1950
1951                 cmd_len = kvaser_usb_hydra_cmd_size(cmd);
1952
1953                 if (pos + cmd_len > len) {
1954                         /* We got first part of a command */
1955                         int leftover_bytes;
1956
1957                         leftover_bytes = len - pos;
1958                         /* Make sure we do not overflow usb_rx_leftover */
1959                         if (leftover_bytes > KVASER_USB_HYDRA_MAX_CMD_LEN) {
1960                                 dev_err(&dev->intf->dev, "Format error\n");
1961                                 return;
1962                         }
1963                         spin_lock_irqsave(usb_rx_leftover_lock, irq_flags);
1964                         memcpy(card_data->usb_rx_leftover, buf + pos,
1965                                leftover_bytes);
1966                         card_data->usb_rx_leftover_len = leftover_bytes;
1967                         spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags);
1968                         break;
1969                 }
1970
1971                 kvaser_usb_hydra_handle_cmd(dev, cmd);
1972                 pos += cmd_len;
1973         }
1974 }
1975
1976 static void *
1977 kvaser_usb_hydra_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
1978                               const struct sk_buff *skb, int *frame_len,
1979                               int *cmd_len, u16 transid)
1980 {
1981         void *buf;
1982
1983         if (priv->dev->card_data.capabilities & KVASER_USB_HYDRA_CAP_EXT_CMD)
1984                 buf = kvaser_usb_hydra_frame_to_cmd_ext(priv, skb, frame_len,
1985                                                         cmd_len, transid);
1986         else
1987                 buf = kvaser_usb_hydra_frame_to_cmd_std(priv, skb, frame_len,
1988                                                         cmd_len, transid);
1989
1990         return buf;
1991 }
1992
1993 const struct kvaser_usb_dev_ops kvaser_usb_hydra_dev_ops = {
1994         .dev_set_mode = kvaser_usb_hydra_set_mode,
1995         .dev_set_bittiming = kvaser_usb_hydra_set_bittiming,
1996         .dev_set_data_bittiming = kvaser_usb_hydra_set_data_bittiming,
1997         .dev_get_berr_counter = kvaser_usb_hydra_get_berr_counter,
1998         .dev_setup_endpoints = kvaser_usb_hydra_setup_endpoints,
1999         .dev_init_card = kvaser_usb_hydra_init_card,
2000         .dev_get_software_info = kvaser_usb_hydra_get_software_info,
2001         .dev_get_software_details = kvaser_usb_hydra_get_software_details,
2002         .dev_get_card_info = kvaser_usb_hydra_get_card_info,
2003         .dev_get_capabilities = kvaser_usb_hydra_get_capabilities,
2004         .dev_set_opt_mode = kvaser_usb_hydra_set_opt_mode,
2005         .dev_start_chip = kvaser_usb_hydra_start_chip,
2006         .dev_stop_chip = kvaser_usb_hydra_stop_chip,
2007         .dev_reset_chip = NULL,
2008         .dev_flush_queue = kvaser_usb_hydra_flush_queue,
2009         .dev_read_bulk_callback = kvaser_usb_hydra_read_bulk_callback,
2010         .dev_frame_to_cmd = kvaser_usb_hydra_frame_to_cmd,
2011 };
2012
2013 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_kcan = {
2014         .clock = {
2015                 .freq = 80000000,
2016         },
2017         .timestamp_freq = 80,
2018         .bittiming_const = &kvaser_usb_hydra_kcan_bittiming_c,
2019         .data_bittiming_const = &kvaser_usb_hydra_kcan_bittiming_c,
2020 };
2021
2022 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_flexc = {
2023         .clock = {
2024                 .freq = 24000000,
2025         },
2026         .timestamp_freq = 1,
2027         .bittiming_const = &kvaser_usb_hydra_flexc_bittiming_c,
2028 };