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