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