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
6 * Copyright (C) 2018 KVASER AB, Sweden. All rights reserved.
7 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
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.
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>
27 #include <linux/can.h>
28 #include <linux/can/dev.h>
29 #include <linux/can/error.h>
30 #include <linux/can/netlink.h>
32 #include "kvaser_usb.h"
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;
38 #define KVASER_USB_HYDRA_BULK_EP_IN_ADDR 0x82
39 #define KVASER_USB_HYDRA_BULK_EP_OUT_ADDR 0x02
41 #define KVASER_USB_HYDRA_MAX_TRANSID 0xff
42 #define KVASER_USB_HYDRA_MIN_TRANSID 0x01
44 /* Minihydra command IDs */
45 #define CMD_SET_BUSPARAMS_REQ 16
46 #define CMD_GET_CHIP_STATE_REQ 19
47 #define CMD_CHIP_STATE_EVENT 20
48 #define CMD_SET_DRIVERMODE_REQ 21
49 #define CMD_START_CHIP_REQ 26
50 #define CMD_START_CHIP_RESP 27
51 #define CMD_STOP_CHIP_REQ 28
52 #define CMD_STOP_CHIP_RESP 29
53 #define CMD_TX_CAN_MESSAGE 33
54 #define CMD_GET_CARD_INFO_REQ 34
55 #define CMD_GET_CARD_INFO_RESP 35
56 #define CMD_GET_SOFTWARE_INFO_REQ 38
57 #define CMD_GET_SOFTWARE_INFO_RESP 39
58 #define CMD_ERROR_EVENT 45
59 #define CMD_FLUSH_QUEUE 48
60 #define CMD_TX_ACKNOWLEDGE 50
61 #define CMD_FLUSH_QUEUE_RESP 66
62 #define CMD_SET_BUSPARAMS_FD_REQ 69
63 #define CMD_SET_BUSPARAMS_FD_RESP 70
64 #define CMD_SET_BUSPARAMS_RESP 85
65 #define CMD_GET_CAPABILITIES_REQ 95
66 #define CMD_GET_CAPABILITIES_RESP 96
67 #define CMD_RX_MESSAGE 106
68 #define CMD_MAP_CHANNEL_REQ 200
69 #define CMD_MAP_CHANNEL_RESP 201
70 #define CMD_GET_SOFTWARE_DETAILS_REQ 202
71 #define CMD_GET_SOFTWARE_DETAILS_RESP 203
72 #define CMD_EXTENDED 255
74 /* Minihydra extended command IDs */
75 #define CMD_TX_CAN_MESSAGE_FD 224
76 #define CMD_TX_ACKNOWLEDGE_FD 225
77 #define CMD_RX_MESSAGE_FD 226
79 /* Hydra commands are handled by different threads in firmware.
80 * The threads are denoted hydra entity (HE). Each HE got a unique 6-bit
81 * address. The address is used in hydra commands to get/set source and
82 * destination HE. There are two predefined HE addresses, the remaining
83 * addresses are different between devices and firmware versions. Hence, we need
84 * to enumerate the addresses (see kvaser_usb_hydra_map_channel()).
87 /* Well-known HE addresses */
88 #define KVASER_USB_HYDRA_HE_ADDRESS_ROUTER 0x00
89 #define KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL 0x3e
91 #define KVASER_USB_HYDRA_TRANSID_CANHE 0x40
92 #define KVASER_USB_HYDRA_TRANSID_SYSDBG 0x61
94 struct kvaser_cmd_map_ch_req {
100 struct kvaser_cmd_map_ch_res {
106 struct kvaser_cmd_card_info {
107 __le32 serial_number;
119 struct kvaser_cmd_sw_info {
121 __le16 max_outstanding_tx;
125 struct kvaser_cmd_sw_detail_req {
130 /* Software detail flags */
131 #define KVASER_USB_HYDRA_SW_FLAG_FW_BETA BIT(2)
132 #define KVASER_USB_HYDRA_SW_FLAG_FW_BAD BIT(4)
133 #define KVASER_USB_HYDRA_SW_FLAG_FREQ_80M BIT(5)
134 #define KVASER_USB_HYDRA_SW_FLAG_EXT_CMD BIT(9)
135 #define KVASER_USB_HYDRA_SW_FLAG_CANFD BIT(10)
136 #define KVASER_USB_HYDRA_SW_FLAG_NONISO BIT(11)
137 #define KVASER_USB_HYDRA_SW_FLAG_EXT_CAP BIT(12)
138 struct kvaser_cmd_sw_detail_res {
147 /* Sub commands for cap_req and cap_res */
148 #define KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE 0x02
149 #define KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT 0x05
150 #define KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT 0x06
151 struct kvaser_cmd_cap_req {
156 /* Status codes for cap_res */
157 #define KVASER_USB_HYDRA_CAP_STAT_OK 0x00
158 #define KVASER_USB_HYDRA_CAP_STAT_NOT_IMPL 0x01
159 #define KVASER_USB_HYDRA_CAP_STAT_UNAVAIL 0x02
160 struct kvaser_cmd_cap_res {
168 /* CMD_ERROR_EVENT error codes */
169 #define KVASER_USB_HYDRA_ERROR_EVENT_CAN 0x01
170 #define KVASER_USB_HYDRA_ERROR_EVENT_PARAM 0x09
171 struct kvaser_cmd_error_event {
179 /* Chip state status flags. Used for chip_state_event and err_frame_data. */
180 #define KVASER_USB_HYDRA_BUS_ERR_ACT 0x00
181 #define KVASER_USB_HYDRA_BUS_ERR_PASS BIT(5)
182 #define KVASER_USB_HYDRA_BUS_BUS_OFF BIT(6)
183 struct kvaser_cmd_chip_state_event {
192 #define KVASER_USB_HYDRA_BUS_MODE_CAN 0x00
193 #define KVASER_USB_HYDRA_BUS_MODE_CANFD_ISO 0x01
194 #define KVASER_USB_HYDRA_BUS_MODE_NONISO 0x02
195 struct kvaser_cmd_set_busparams {
212 #define KVASER_USB_HYDRA_CTRLMODE_NORMAL 0x01
213 #define KVASER_USB_HYDRA_CTRLMODE_LISTEN 0x02
214 struct kvaser_cmd_set_ctrlmode {
219 struct kvaser_err_frame_data {
227 struct kvaser_cmd_rx_can {
238 struct kvaser_err_frame_data err_frame_data;
242 /* Extended CAN ID flag. Used in rx_can and tx_can */
243 #define KVASER_USB_HYDRA_EXTENDED_FRAME_ID BIT(31)
244 struct kvaser_cmd_tx_can {
254 struct kvaser_cmd_header {
256 /* The destination HE address is stored in 0..5 of he_addr.
257 * The upper part of source HE address is stored in 6..7 of he_addr, and
258 * the lower part is stored in 12..15 of transid.
265 struct kvaser_cmd_header header;
267 struct kvaser_cmd_map_ch_req map_ch_req;
268 struct kvaser_cmd_map_ch_res map_ch_res;
270 struct kvaser_cmd_card_info card_info;
271 struct kvaser_cmd_sw_info sw_info;
272 struct kvaser_cmd_sw_detail_req sw_detail_req;
273 struct kvaser_cmd_sw_detail_res sw_detail_res;
275 struct kvaser_cmd_cap_req cap_req;
276 struct kvaser_cmd_cap_res cap_res;
278 struct kvaser_cmd_error_event error_event;
280 struct kvaser_cmd_set_busparams set_busparams_req;
282 struct kvaser_cmd_chip_state_event chip_state_event;
284 struct kvaser_cmd_set_ctrlmode set_ctrlmode;
286 struct kvaser_cmd_rx_can rx_can;
287 struct kvaser_cmd_tx_can tx_can;
291 /* CAN frame flags. Used in rx_can, ext_rx_can, tx_can and ext_tx_can */
292 #define KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME BIT(0)
293 #define KVASER_USB_HYDRA_CF_FLAG_OVERRUN BIT(1)
294 #define KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME BIT(4)
295 #define KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID BIT(5)
296 /* CAN frame flags. Used in ext_rx_can and ext_tx_can */
297 #define KVASER_USB_HYDRA_CF_FLAG_OSM_NACK BIT(12)
298 #define KVASER_USB_HYDRA_CF_FLAG_ABL BIT(13)
299 #define KVASER_USB_HYDRA_CF_FLAG_FDF BIT(16)
300 #define KVASER_USB_HYDRA_CF_FLAG_BRS BIT(17)
301 #define KVASER_USB_HYDRA_CF_FLAG_ESI BIT(18)
303 /* KCAN packet header macros. Used in ext_rx_can and ext_tx_can */
304 #define KVASER_USB_KCAN_DATA_DLC_BITS 4
305 #define KVASER_USB_KCAN_DATA_DLC_SHIFT 8
306 #define KVASER_USB_KCAN_DATA_DLC_MASK \
307 GENMASK(KVASER_USB_KCAN_DATA_DLC_BITS - 1 + \
308 KVASER_USB_KCAN_DATA_DLC_SHIFT, \
309 KVASER_USB_KCAN_DATA_DLC_SHIFT)
311 #define KVASER_USB_KCAN_DATA_BRS BIT(14)
312 #define KVASER_USB_KCAN_DATA_FDF BIT(15)
313 #define KVASER_USB_KCAN_DATA_OSM BIT(16)
314 #define KVASER_USB_KCAN_DATA_AREQ BIT(31)
315 #define KVASER_USB_KCAN_DATA_SRR BIT(31)
316 #define KVASER_USB_KCAN_DATA_RTR BIT(29)
317 #define KVASER_USB_KCAN_DATA_IDE BIT(30)
318 struct kvaser_cmd_ext_rx_can {
326 struct kvaser_err_frame_data err_frame_data;
330 struct kvaser_cmd_ext_tx_can {
341 struct kvaser_cmd_ext_tx_ack {
348 /* struct for extended commands (CMD_EXTENDED) */
349 struct kvaser_cmd_ext {
350 struct kvaser_cmd_header header;
356 struct kvaser_cmd_ext_rx_can rx_can;
357 struct kvaser_cmd_ext_tx_can tx_can;
358 struct kvaser_cmd_ext_tx_ack tx_ack;
362 static const struct can_bittiming_const kvaser_usb_hydra_kcan_bittiming_c = {
363 .name = "kvaser_usb_kcan",
374 const struct can_bittiming_const kvaser_usb_flexc_bittiming_const = {
375 .name = "kvaser_usb_flex",
386 #define KVASER_USB_HYDRA_TRANSID_BITS 12
387 #define KVASER_USB_HYDRA_TRANSID_MASK \
388 GENMASK(KVASER_USB_HYDRA_TRANSID_BITS - 1, 0)
389 #define KVASER_USB_HYDRA_HE_ADDR_SRC_MASK GENMASK(7, 6)
390 #define KVASER_USB_HYDRA_HE_ADDR_DEST_MASK GENMASK(5, 0)
391 #define KVASER_USB_HYDRA_HE_ADDR_SRC_BITS 2
392 static inline u16 kvaser_usb_hydra_get_cmd_transid(const struct kvaser_cmd *cmd)
394 return le16_to_cpu(cmd->header.transid) & KVASER_USB_HYDRA_TRANSID_MASK;
397 static inline void kvaser_usb_hydra_set_cmd_transid(struct kvaser_cmd *cmd,
400 cmd->header.transid =
401 cpu_to_le16(transid & KVASER_USB_HYDRA_TRANSID_MASK);
404 static inline u8 kvaser_usb_hydra_get_cmd_src_he(const struct kvaser_cmd *cmd)
406 return (cmd->header.he_addr & KVASER_USB_HYDRA_HE_ADDR_SRC_MASK) >>
407 KVASER_USB_HYDRA_HE_ADDR_SRC_BITS |
408 le16_to_cpu(cmd->header.transid) >>
409 KVASER_USB_HYDRA_TRANSID_BITS;
412 static inline void kvaser_usb_hydra_set_cmd_dest_he(struct kvaser_cmd *cmd,
415 cmd->header.he_addr =
416 (cmd->header.he_addr & KVASER_USB_HYDRA_HE_ADDR_SRC_MASK) |
417 (dest_he & KVASER_USB_HYDRA_HE_ADDR_DEST_MASK);
420 static u8 kvaser_usb_hydra_channel_from_cmd(const struct kvaser_usb *dev,
421 const struct kvaser_cmd *cmd)
425 u8 src_he = kvaser_usb_hydra_get_cmd_src_he(cmd);
427 for (i = 0; i < KVASER_USB_MAX_NET_DEVICES; i++) {
428 if (dev->card_data.hydra.channel_to_he[i] == src_he) {
437 static u16 kvaser_usb_hydra_get_next_transid(struct kvaser_usb *dev)
441 struct kvaser_usb_dev_card_data_hydra *card_data =
442 &dev->card_data.hydra;
444 spin_lock_irqsave(&card_data->transid_lock, flags);
445 transid = card_data->transid;
446 if (transid >= KVASER_USB_HYDRA_MAX_TRANSID)
447 transid = KVASER_USB_HYDRA_MIN_TRANSID;
450 card_data->transid = transid;
451 spin_unlock_irqrestore(&card_data->transid_lock, flags);
456 static size_t kvaser_usb_hydra_cmd_size(struct kvaser_cmd *cmd)
460 if (cmd->header.cmd_no == CMD_EXTENDED)
461 ret = le16_to_cpu(((struct kvaser_cmd_ext *)cmd)->len);
463 ret = sizeof(struct kvaser_cmd);
468 static struct kvaser_usb_net_priv *
469 kvaser_usb_hydra_net_priv_from_cmd(const struct kvaser_usb *dev,
470 const struct kvaser_cmd *cmd)
472 struct kvaser_usb_net_priv *priv = NULL;
473 u8 channel = kvaser_usb_hydra_channel_from_cmd(dev, cmd);
475 if (channel >= dev->nchannels)
476 dev_err(&dev->intf->dev,
477 "Invalid channel number (%d)\n", channel);
479 priv = dev->nets[channel];
485 kvaser_usb_hydra_ktime_from_rx_cmd(const struct kvaser_usb_dev_cfg *cfg,
486 const struct kvaser_cmd *cmd)
490 if (cmd->header.cmd_no == CMD_EXTENDED) {
491 struct kvaser_cmd_ext *cmd_ext = (struct kvaser_cmd_ext *)cmd;
493 ticks = le64_to_cpu(cmd_ext->rx_can.timestamp);
495 ticks = le16_to_cpu(cmd->rx_can.timestamp[0]);
496 ticks += (u64)(le16_to_cpu(cmd->rx_can.timestamp[1])) << 16;
497 ticks += (u64)(le16_to_cpu(cmd->rx_can.timestamp[2])) << 32;
500 return ns_to_ktime(div_u64(ticks * 1000, cfg->timestamp_freq));
503 static int kvaser_usb_hydra_send_simple_cmd(struct kvaser_usb *dev,
504 u8 cmd_no, int channel)
506 struct kvaser_cmd *cmd;
509 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
513 cmd->header.cmd_no = cmd_no;
515 kvaser_usb_hydra_set_cmd_dest_he
516 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL);
518 if (channel >= KVASER_USB_MAX_NET_DEVICES) {
519 dev_err(&dev->intf->dev, "channel (%d) out of range.\n",
524 kvaser_usb_hydra_set_cmd_dest_he
525 (cmd, dev->card_data.hydra.channel_to_he[channel]);
527 kvaser_usb_hydra_set_cmd_transid
528 (cmd, kvaser_usb_hydra_get_next_transid(dev));
530 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
541 kvaser_usb_hydra_send_simple_cmd_async(struct kvaser_usb_net_priv *priv,
544 struct kvaser_cmd *cmd;
545 struct kvaser_usb *dev = priv->dev;
548 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_ATOMIC);
552 cmd->header.cmd_no = cmd_no;
554 kvaser_usb_hydra_set_cmd_dest_he
555 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
556 kvaser_usb_hydra_set_cmd_transid
557 (cmd, kvaser_usb_hydra_get_next_transid(dev));
559 err = kvaser_usb_send_cmd_async(priv, cmd,
560 kvaser_usb_hydra_cmd_size(cmd));
567 /* This function is used for synchronously waiting on hydra control commands.
568 * Note: Compared to kvaser_usb_hydra_read_bulk_callback(), we never need to
569 * handle partial hydra commands. Since hydra control commands are always
570 * non-extended commands.
572 static int kvaser_usb_hydra_wait_cmd(const struct kvaser_usb *dev, u8 cmd_no,
573 struct kvaser_cmd *cmd)
577 unsigned long timeout = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT);
579 if (cmd->header.cmd_no == CMD_EXTENDED) {
580 dev_err(&dev->intf->dev, "Wait for CMD_EXTENDED not allowed\n");
584 buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL);
592 err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE,
597 while (pos < actual_len) {
598 struct kvaser_cmd *tmp_cmd;
602 cmd_len = kvaser_usb_hydra_cmd_size(tmp_cmd);
603 if (pos + cmd_len > actual_len) {
604 dev_err_ratelimited(&dev->intf->dev,
609 if (tmp_cmd->header.cmd_no == cmd_no) {
610 memcpy(cmd, tmp_cmd, cmd_len);
615 } while (time_before(jiffies, timeout));
625 static int kvaser_usb_hydra_map_channel_resp(struct kvaser_usb *dev,
626 const struct kvaser_cmd *cmd)
629 u16 transid = kvaser_usb_hydra_get_cmd_transid(cmd);
630 struct kvaser_usb_dev_card_data_hydra *card_data =
631 &dev->card_data.hydra;
633 if (transid > 0x007f || transid < 0x0040) {
634 dev_err(&dev->intf->dev,
635 "CMD_MAP_CHANNEL_RESP, invalid transid: 0x%x\n",
641 case KVASER_USB_HYDRA_TRANSID_CANHE:
642 case KVASER_USB_HYDRA_TRANSID_CANHE + 1:
643 case KVASER_USB_HYDRA_TRANSID_CANHE + 2:
644 case KVASER_USB_HYDRA_TRANSID_CANHE + 3:
645 case KVASER_USB_HYDRA_TRANSID_CANHE + 4:
646 channel = transid & 0x000f;
647 he = cmd->map_ch_res.he_addr;
648 card_data->channel_to_he[channel] = he;
650 case KVASER_USB_HYDRA_TRANSID_SYSDBG:
651 card_data->sysdbg_he = cmd->map_ch_res.he_addr;
654 dev_warn(&dev->intf->dev,
655 "Unknown CMD_MAP_CHANNEL_RESP transid=0x%x\n",
663 static int kvaser_usb_hydra_map_channel(struct kvaser_usb *dev, u16 transid,
664 u8 channel, const char *name)
666 struct kvaser_cmd *cmd;
669 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
673 strcpy(cmd->map_ch_req.name, name);
674 cmd->header.cmd_no = CMD_MAP_CHANNEL_REQ;
675 kvaser_usb_hydra_set_cmd_dest_he
676 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ROUTER);
677 cmd->map_ch_req.channel = channel;
679 kvaser_usb_hydra_set_cmd_transid(cmd, transid);
681 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
685 err = kvaser_usb_hydra_wait_cmd(dev, CMD_MAP_CHANNEL_RESP, cmd);
689 err = kvaser_usb_hydra_map_channel_resp(dev, cmd);
699 static int kvaser_usb_hydra_get_single_capability(struct kvaser_usb *dev,
700 u16 cap_cmd_req, u16 *status)
702 struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
703 struct kvaser_cmd *cmd;
710 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
714 cmd->header.cmd_no = CMD_GET_CAPABILITIES_REQ;
715 cmd->cap_req.cap_cmd = cpu_to_le16(cap_cmd_req);
717 kvaser_usb_hydra_set_cmd_dest_he(cmd, card_data->hydra.sysdbg_he);
718 kvaser_usb_hydra_set_cmd_transid
719 (cmd, kvaser_usb_hydra_get_next_transid(dev));
721 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
725 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_CAPABILITIES_RESP, cmd);
729 *status = le16_to_cpu(cmd->cap_res.status);
731 if (*status != KVASER_USB_HYDRA_CAP_STAT_OK)
734 cap_cmd_res = le16_to_cpu(cmd->cap_res.cap_cmd);
735 switch (cap_cmd_res) {
736 case KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE:
737 case KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT:
738 case KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT:
739 value = le32_to_cpu(cmd->cap_res.value);
740 mask = le32_to_cpu(cmd->cap_res.mask);
743 dev_warn(&dev->intf->dev, "Unknown capability command %u\n",
748 for (i = 0; i < dev->nchannels; i++) {
749 if (BIT(i) & (value & mask)) {
750 switch (cap_cmd_res) {
751 case KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE:
752 card_data->ctrlmode_supported |=
753 CAN_CTRLMODE_LISTENONLY;
755 case KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT:
756 card_data->capabilities |=
757 KVASER_USB_CAP_BERR_CAP;
759 case KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT:
760 card_data->ctrlmode_supported |=
761 CAN_CTRLMODE_ONE_SHOT;
773 static void kvaser_usb_hydra_start_chip_reply(const struct kvaser_usb *dev,
774 const struct kvaser_cmd *cmd)
776 struct kvaser_usb_net_priv *priv;
778 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
782 if (completion_done(&priv->start_comp) &&
783 netif_queue_stopped(priv->netdev)) {
784 netif_wake_queue(priv->netdev);
786 netif_start_queue(priv->netdev);
787 complete(&priv->start_comp);
791 static void kvaser_usb_hydra_stop_chip_reply(const struct kvaser_usb *dev,
792 const struct kvaser_cmd *cmd)
794 struct kvaser_usb_net_priv *priv;
796 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
800 complete(&priv->stop_comp);
803 static void kvaser_usb_hydra_flush_queue_reply(const struct kvaser_usb *dev,
804 const struct kvaser_cmd *cmd)
806 struct kvaser_usb_net_priv *priv;
808 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
812 complete(&priv->flush_comp);
816 kvaser_usb_hydra_bus_status_to_can_state(const struct kvaser_usb_net_priv *priv,
818 const struct can_berr_counter *bec,
819 enum can_state *new_state)
821 if (bus_status & KVASER_USB_HYDRA_BUS_BUS_OFF) {
822 *new_state = CAN_STATE_BUS_OFF;
823 } else if (bus_status & KVASER_USB_HYDRA_BUS_ERR_PASS) {
824 *new_state = CAN_STATE_ERROR_PASSIVE;
825 } else if (bus_status == KVASER_USB_HYDRA_BUS_ERR_ACT) {
826 if (bec->txerr >= 128 || bec->rxerr >= 128) {
827 netdev_warn(priv->netdev,
828 "ERR_ACTIVE but err tx=%u or rx=%u >=128\n",
829 bec->txerr, bec->rxerr);
830 *new_state = CAN_STATE_ERROR_PASSIVE;
831 } else if (bec->txerr >= 96 || bec->rxerr >= 96) {
832 *new_state = CAN_STATE_ERROR_WARNING;
834 *new_state = CAN_STATE_ERROR_ACTIVE;
839 static void kvaser_usb_hydra_update_state(struct kvaser_usb_net_priv *priv,
841 const struct can_berr_counter *bec)
843 struct net_device *netdev = priv->netdev;
844 struct can_frame *cf;
846 struct net_device_stats *stats;
847 enum can_state new_state, old_state;
849 old_state = priv->can.state;
851 kvaser_usb_hydra_bus_status_to_can_state(priv, bus_status, bec,
854 if (new_state == old_state)
857 /* Ignore state change if previous state was STOPPED and the new state
858 * is BUS_OFF. Firmware always report this as BUS_OFF, since firmware
859 * does not distinguish between BUS_OFF and STOPPED.
861 if (old_state == CAN_STATE_STOPPED && new_state == CAN_STATE_BUS_OFF)
864 skb = alloc_can_err_skb(netdev, &cf);
866 enum can_state tx_state, rx_state;
868 tx_state = (bec->txerr >= bec->rxerr) ?
869 new_state : CAN_STATE_ERROR_ACTIVE;
870 rx_state = (bec->txerr <= bec->rxerr) ?
871 new_state : CAN_STATE_ERROR_ACTIVE;
872 can_change_state(netdev, cf, tx_state, rx_state);
875 if (new_state == CAN_STATE_BUS_OFF && old_state < CAN_STATE_BUS_OFF) {
876 if (!priv->can.restart_ms)
877 kvaser_usb_hydra_send_simple_cmd_async
878 (priv, CMD_STOP_CHIP_REQ);
884 netdev_warn(netdev, "No memory left for err_skb\n");
888 if (priv->can.restart_ms &&
889 old_state >= CAN_STATE_BUS_OFF &&
890 new_state < CAN_STATE_BUS_OFF)
891 priv->can.can_stats.restarts++;
893 if (new_state != CAN_STATE_BUS_OFF) {
894 cf->data[6] = bec->txerr;
895 cf->data[7] = bec->rxerr;
898 stats = &netdev->stats;
900 stats->rx_bytes += cf->can_dlc;
904 static void kvaser_usb_hydra_state_event(const struct kvaser_usb *dev,
905 const struct kvaser_cmd *cmd)
907 struct kvaser_usb_net_priv *priv;
908 struct can_berr_counter bec;
911 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
915 bus_status = cmd->chip_state_event.bus_status;
916 bec.txerr = cmd->chip_state_event.tx_err_counter;
917 bec.rxerr = cmd->chip_state_event.rx_err_counter;
919 kvaser_usb_hydra_update_state(priv, bus_status, &bec);
920 priv->bec.txerr = bec.txerr;
921 priv->bec.rxerr = bec.rxerr;
924 static void kvaser_usb_hydra_error_event_parameter(const struct kvaser_usb *dev,
925 const struct kvaser_cmd *cmd)
927 /* info1 will contain the offending cmd_no */
928 switch (le16_to_cpu(cmd->error_event.info1)) {
929 case CMD_START_CHIP_REQ:
930 dev_warn(&dev->intf->dev,
931 "CMD_START_CHIP_REQ error in parameter\n");
934 case CMD_STOP_CHIP_REQ:
935 dev_warn(&dev->intf->dev,
936 "CMD_STOP_CHIP_REQ error in parameter\n");
939 case CMD_FLUSH_QUEUE:
940 dev_warn(&dev->intf->dev,
941 "CMD_FLUSH_QUEUE error in parameter\n");
944 case CMD_SET_BUSPARAMS_REQ:
945 dev_warn(&dev->intf->dev,
946 "Set bittiming failed. Error in parameter\n");
949 case CMD_SET_BUSPARAMS_FD_REQ:
950 dev_warn(&dev->intf->dev,
951 "Set data bittiming failed. Error in parameter\n");
955 dev_warn(&dev->intf->dev,
956 "Unhandled parameter error event cmd_no (%u)\n",
957 le16_to_cpu(cmd->error_event.info1));
962 static void kvaser_usb_hydra_error_event(const struct kvaser_usb *dev,
963 const struct kvaser_cmd *cmd)
965 switch (cmd->error_event.error_code) {
966 case KVASER_USB_HYDRA_ERROR_EVENT_PARAM:
967 kvaser_usb_hydra_error_event_parameter(dev, cmd);
970 case KVASER_USB_HYDRA_ERROR_EVENT_CAN:
971 /* Wrong channel mapping?! This should never happen!
972 * info1 will contain the offending cmd_no
974 dev_err(&dev->intf->dev,
975 "Received CAN error event for cmd_no (%u)\n",
976 le16_to_cpu(cmd->error_event.info1));
980 dev_warn(&dev->intf->dev,
981 "Unhandled error event (%d)\n",
982 cmd->error_event.error_code);
988 kvaser_usb_hydra_error_frame(struct kvaser_usb_net_priv *priv,
989 const struct kvaser_err_frame_data *err_frame_data,
992 struct net_device *netdev = priv->netdev;
993 struct net_device_stats *stats = &netdev->stats;
994 struct can_frame *cf;
996 struct skb_shared_hwtstamps *shhwtstamps;
997 struct can_berr_counter bec;
998 enum can_state new_state, old_state;
1001 priv->can.can_stats.bus_error++;
1004 bus_status = err_frame_data->bus_status;
1005 bec.txerr = err_frame_data->tx_err_counter;
1006 bec.rxerr = err_frame_data->rx_err_counter;
1008 old_state = priv->can.state;
1009 kvaser_usb_hydra_bus_status_to_can_state(priv, bus_status, &bec,
1012 skb = alloc_can_err_skb(netdev, &cf);
1014 if (new_state != old_state) {
1016 enum can_state tx_state, rx_state;
1018 tx_state = (bec.txerr >= bec.rxerr) ?
1019 new_state : CAN_STATE_ERROR_ACTIVE;
1020 rx_state = (bec.txerr <= bec.rxerr) ?
1021 new_state : CAN_STATE_ERROR_ACTIVE;
1023 can_change_state(netdev, cf, tx_state, rx_state);
1025 if (priv->can.restart_ms &&
1026 old_state >= CAN_STATE_BUS_OFF &&
1027 new_state < CAN_STATE_BUS_OFF)
1028 cf->can_id |= CAN_ERR_RESTARTED;
1031 if (new_state == CAN_STATE_BUS_OFF) {
1032 if (!priv->can.restart_ms)
1033 kvaser_usb_hydra_send_simple_cmd_async
1034 (priv, CMD_STOP_CHIP_REQ);
1036 can_bus_off(netdev);
1041 stats->rx_dropped++;
1042 netdev_warn(netdev, "No memory left for err_skb\n");
1046 shhwtstamps = skb_hwtstamps(skb);
1047 shhwtstamps->hwtstamp = hwtstamp;
1049 cf->can_id |= CAN_ERR_BUSERROR;
1050 if (new_state != CAN_STATE_BUS_OFF) {
1051 cf->data[6] = bec.txerr;
1052 cf->data[7] = bec.rxerr;
1055 stats->rx_packets++;
1056 stats->rx_bytes += cf->can_dlc;
1059 priv->bec.txerr = bec.txerr;
1060 priv->bec.rxerr = bec.rxerr;
1063 static void kvaser_usb_hydra_one_shot_fail(struct kvaser_usb_net_priv *priv,
1064 const struct kvaser_cmd_ext *cmd)
1066 struct net_device *netdev = priv->netdev;
1067 struct net_device_stats *stats = &netdev->stats;
1068 struct can_frame *cf;
1069 struct sk_buff *skb;
1072 skb = alloc_can_err_skb(netdev, &cf);
1074 stats->rx_dropped++;
1075 netdev_warn(netdev, "No memory left for err_skb\n");
1079 cf->can_id |= CAN_ERR_BUSERROR;
1080 flags = le32_to_cpu(cmd->tx_ack.flags);
1082 if (flags & KVASER_USB_HYDRA_CF_FLAG_OSM_NACK)
1083 cf->can_id |= CAN_ERR_ACK;
1084 if (flags & KVASER_USB_HYDRA_CF_FLAG_ABL) {
1085 cf->can_id |= CAN_ERR_LOSTARB;
1086 priv->can.can_stats.arbitration_lost++;
1090 stats->rx_packets++;
1091 stats->rx_bytes += cf->can_dlc;
1095 static void kvaser_usb_hydra_tx_acknowledge(const struct kvaser_usb *dev,
1096 const struct kvaser_cmd *cmd)
1098 struct kvaser_usb_tx_urb_context *context;
1099 struct kvaser_usb_net_priv *priv;
1100 unsigned long irq_flags;
1101 bool one_shot_fail = false;
1102 u16 transid = kvaser_usb_hydra_get_cmd_transid(cmd);
1104 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
1108 if (!netif_device_present(priv->netdev))
1111 if (cmd->header.cmd_no == CMD_EXTENDED) {
1112 struct kvaser_cmd_ext *cmd_ext = (struct kvaser_cmd_ext *)cmd;
1113 u32 flags = le32_to_cpu(cmd_ext->tx_ack.flags);
1115 if (flags & (KVASER_USB_HYDRA_CF_FLAG_OSM_NACK |
1116 KVASER_USB_HYDRA_CF_FLAG_ABL)) {
1117 kvaser_usb_hydra_one_shot_fail(priv, cmd_ext);
1118 one_shot_fail = true;
1122 context = &priv->tx_contexts[transid % dev->max_tx_urbs];
1123 if (!one_shot_fail) {
1124 struct net_device_stats *stats = &priv->netdev->stats;
1126 stats->tx_packets++;
1127 stats->tx_bytes += can_dlc2len(context->dlc);
1130 spin_lock_irqsave(&priv->tx_contexts_lock, irq_flags);
1132 can_get_echo_skb(priv->netdev, context->echo_index);
1133 context->echo_index = dev->max_tx_urbs;
1134 --priv->active_tx_contexts;
1135 netif_wake_queue(priv->netdev);
1137 spin_unlock_irqrestore(&priv->tx_contexts_lock, irq_flags);
1140 static void kvaser_usb_hydra_rx_msg_std(const struct kvaser_usb *dev,
1141 const struct kvaser_cmd *cmd)
1143 struct kvaser_usb_net_priv *priv = NULL;
1144 struct can_frame *cf;
1145 struct sk_buff *skb;
1146 struct skb_shared_hwtstamps *shhwtstamps;
1147 struct net_device_stats *stats;
1151 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, cmd);
1155 stats = &priv->netdev->stats;
1157 flags = cmd->rx_can.flags;
1158 hwtstamp = kvaser_usb_hydra_ktime_from_rx_cmd(dev->cfg, cmd);
1160 if (flags & KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME) {
1161 kvaser_usb_hydra_error_frame(priv, &cmd->rx_can.err_frame_data,
1166 skb = alloc_can_skb(priv->netdev, &cf);
1168 stats->rx_dropped++;
1172 shhwtstamps = skb_hwtstamps(skb);
1173 shhwtstamps->hwtstamp = hwtstamp;
1175 cf->can_id = le32_to_cpu(cmd->rx_can.id);
1177 if (cf->can_id & KVASER_USB_HYDRA_EXTENDED_FRAME_ID) {
1178 cf->can_id &= CAN_EFF_MASK;
1179 cf->can_id |= CAN_EFF_FLAG;
1181 cf->can_id &= CAN_SFF_MASK;
1184 if (flags & KVASER_USB_HYDRA_CF_FLAG_OVERRUN)
1185 kvaser_usb_can_rx_over_error(priv->netdev);
1187 cf->can_dlc = get_can_dlc(cmd->rx_can.dlc);
1189 if (flags & KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME)
1190 cf->can_id |= CAN_RTR_FLAG;
1192 memcpy(cf->data, cmd->rx_can.data, cf->can_dlc);
1194 stats->rx_packets++;
1195 stats->rx_bytes += cf->can_dlc;
1199 static void kvaser_usb_hydra_rx_msg_ext(const struct kvaser_usb *dev,
1200 const struct kvaser_cmd_ext *cmd)
1202 struct kvaser_cmd *std_cmd = (struct kvaser_cmd *)cmd;
1203 struct kvaser_usb_net_priv *priv;
1204 struct canfd_frame *cf;
1205 struct sk_buff *skb;
1206 struct skb_shared_hwtstamps *shhwtstamps;
1207 struct net_device_stats *stats;
1213 priv = kvaser_usb_hydra_net_priv_from_cmd(dev, std_cmd);
1217 stats = &priv->netdev->stats;
1219 kcan_header = le32_to_cpu(cmd->rx_can.kcan_header);
1220 dlc = (kcan_header & KVASER_USB_KCAN_DATA_DLC_MASK) >>
1221 KVASER_USB_KCAN_DATA_DLC_SHIFT;
1223 flags = le32_to_cpu(cmd->rx_can.flags);
1224 hwtstamp = kvaser_usb_hydra_ktime_from_rx_cmd(dev->cfg, std_cmd);
1226 if (flags & KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME) {
1227 kvaser_usb_hydra_error_frame(priv, &cmd->rx_can.err_frame_data,
1232 if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF)
1233 skb = alloc_canfd_skb(priv->netdev, &cf);
1235 skb = alloc_can_skb(priv->netdev, (struct can_frame **)&cf);
1238 stats->rx_dropped++;
1242 shhwtstamps = skb_hwtstamps(skb);
1243 shhwtstamps->hwtstamp = hwtstamp;
1245 cf->can_id = le32_to_cpu(cmd->rx_can.id);
1247 if (flags & KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID) {
1248 cf->can_id &= CAN_EFF_MASK;
1249 cf->can_id |= CAN_EFF_FLAG;
1251 cf->can_id &= CAN_SFF_MASK;
1254 if (flags & KVASER_USB_HYDRA_CF_FLAG_OVERRUN)
1255 kvaser_usb_can_rx_over_error(priv->netdev);
1257 if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF) {
1258 cf->len = can_dlc2len(get_canfd_dlc(dlc));
1259 if (flags & KVASER_USB_HYDRA_CF_FLAG_BRS)
1260 cf->flags |= CANFD_BRS;
1261 if (flags & KVASER_USB_HYDRA_CF_FLAG_ESI)
1262 cf->flags |= CANFD_ESI;
1264 cf->len = get_can_dlc(dlc);
1267 if (flags & KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME)
1268 cf->can_id |= CAN_RTR_FLAG;
1270 memcpy(cf->data, cmd->rx_can.kcan_payload, cf->len);
1272 stats->rx_packets++;
1273 stats->rx_bytes += cf->len;
1277 static void kvaser_usb_hydra_handle_cmd_std(const struct kvaser_usb *dev,
1278 const struct kvaser_cmd *cmd)
1280 switch (cmd->header.cmd_no) {
1281 case CMD_START_CHIP_RESP:
1282 kvaser_usb_hydra_start_chip_reply(dev, cmd);
1285 case CMD_STOP_CHIP_RESP:
1286 kvaser_usb_hydra_stop_chip_reply(dev, cmd);
1289 case CMD_FLUSH_QUEUE_RESP:
1290 kvaser_usb_hydra_flush_queue_reply(dev, cmd);
1293 case CMD_CHIP_STATE_EVENT:
1294 kvaser_usb_hydra_state_event(dev, cmd);
1297 case CMD_ERROR_EVENT:
1298 kvaser_usb_hydra_error_event(dev, cmd);
1301 case CMD_TX_ACKNOWLEDGE:
1302 kvaser_usb_hydra_tx_acknowledge(dev, cmd);
1305 case CMD_RX_MESSAGE:
1306 kvaser_usb_hydra_rx_msg_std(dev, cmd);
1309 /* Ignored commands */
1310 case CMD_SET_BUSPARAMS_RESP:
1311 case CMD_SET_BUSPARAMS_FD_RESP:
1315 dev_warn(&dev->intf->dev, "Unhandled command (%d)\n",
1316 cmd->header.cmd_no);
1321 static void kvaser_usb_hydra_handle_cmd_ext(const struct kvaser_usb *dev,
1322 const struct kvaser_cmd_ext *cmd)
1324 switch (cmd->cmd_no_ext) {
1325 case CMD_TX_ACKNOWLEDGE_FD:
1326 kvaser_usb_hydra_tx_acknowledge(dev, (struct kvaser_cmd *)cmd);
1329 case CMD_RX_MESSAGE_FD:
1330 kvaser_usb_hydra_rx_msg_ext(dev, cmd);
1334 dev_warn(&dev->intf->dev, "Unhandled extended command (%d)\n",
1335 cmd->header.cmd_no);
1340 static void kvaser_usb_hydra_handle_cmd(const struct kvaser_usb *dev,
1341 const struct kvaser_cmd *cmd)
1343 if (cmd->header.cmd_no == CMD_EXTENDED)
1344 kvaser_usb_hydra_handle_cmd_ext
1345 (dev, (struct kvaser_cmd_ext *)cmd);
1347 kvaser_usb_hydra_handle_cmd_std(dev, cmd);
1351 kvaser_usb_hydra_frame_to_cmd_ext(const struct kvaser_usb_net_priv *priv,
1352 const struct sk_buff *skb, int *frame_len,
1353 int *cmd_len, u16 transid)
1355 struct kvaser_usb *dev = priv->dev;
1356 struct kvaser_cmd_ext *cmd;
1357 struct canfd_frame *cf = (struct canfd_frame *)skb->data;
1358 u8 dlc = can_len2dlc(cf->len);
1359 u8 nbr_of_bytes = cf->len;
1365 *frame_len = nbr_of_bytes;
1367 cmd = kcalloc(1, sizeof(struct kvaser_cmd_ext), GFP_ATOMIC);
1371 kvaser_usb_hydra_set_cmd_dest_he
1372 ((struct kvaser_cmd *)cmd,
1373 dev->card_data.hydra.channel_to_he[priv->channel]);
1374 kvaser_usb_hydra_set_cmd_transid((struct kvaser_cmd *)cmd, transid);
1376 cmd->header.cmd_no = CMD_EXTENDED;
1377 cmd->cmd_no_ext = CMD_TX_CAN_MESSAGE_FD;
1379 *cmd_len = ALIGN(sizeof(struct kvaser_cmd_ext) -
1380 sizeof(cmd->tx_can.kcan_payload) + nbr_of_bytes,
1383 cmd->len = cpu_to_le16(*cmd_len);
1385 cmd->tx_can.databytes = nbr_of_bytes;
1386 cmd->tx_can.dlc = dlc;
1388 if (cf->can_id & CAN_EFF_FLAG) {
1389 id = cf->can_id & CAN_EFF_MASK;
1390 flags = KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID;
1391 kcan_id = (cf->can_id & CAN_EFF_MASK) |
1392 KVASER_USB_KCAN_DATA_IDE | KVASER_USB_KCAN_DATA_SRR;
1394 id = cf->can_id & CAN_SFF_MASK;
1396 kcan_id = cf->can_id & CAN_SFF_MASK;
1399 if (cf->can_id & CAN_ERR_FLAG)
1400 flags |= KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME;
1402 kcan_header = ((dlc << KVASER_USB_KCAN_DATA_DLC_SHIFT) &
1403 KVASER_USB_KCAN_DATA_DLC_MASK) |
1404 KVASER_USB_KCAN_DATA_AREQ |
1405 (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT ?
1406 KVASER_USB_KCAN_DATA_OSM : 0);
1408 if (can_is_canfd_skb(skb)) {
1409 kcan_header |= KVASER_USB_KCAN_DATA_FDF |
1410 (cf->flags & CANFD_BRS ?
1411 KVASER_USB_KCAN_DATA_BRS : 0);
1413 if (cf->can_id & CAN_RTR_FLAG) {
1414 kcan_id |= KVASER_USB_KCAN_DATA_RTR;
1415 cmd->tx_can.databytes = 0;
1416 flags |= KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME;
1420 cmd->tx_can.kcan_id = cpu_to_le32(kcan_id);
1421 cmd->tx_can.id = cpu_to_le32(id);
1422 cmd->tx_can.flags = cpu_to_le32(flags);
1423 cmd->tx_can.kcan_header = cpu_to_le32(kcan_header);
1425 memcpy(cmd->tx_can.kcan_payload, cf->data, nbr_of_bytes);
1431 kvaser_usb_hydra_frame_to_cmd_std(const struct kvaser_usb_net_priv *priv,
1432 const struct sk_buff *skb, int *frame_len,
1433 int *cmd_len, u16 transid)
1435 struct kvaser_usb *dev = priv->dev;
1436 struct kvaser_cmd *cmd;
1437 struct can_frame *cf = (struct can_frame *)skb->data;
1441 *frame_len = cf->can_dlc;
1443 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_ATOMIC);
1447 kvaser_usb_hydra_set_cmd_dest_he
1448 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1449 kvaser_usb_hydra_set_cmd_transid(cmd, transid);
1451 cmd->header.cmd_no = CMD_TX_CAN_MESSAGE;
1453 *cmd_len = ALIGN(sizeof(struct kvaser_cmd), 8);
1455 if (cf->can_id & CAN_EFF_FLAG) {
1456 id = (cf->can_id & CAN_EFF_MASK);
1457 id |= KVASER_USB_HYDRA_EXTENDED_FRAME_ID;
1459 id = cf->can_id & CAN_SFF_MASK;
1462 cmd->tx_can.dlc = cf->can_dlc;
1464 flags = (cf->can_id & CAN_EFF_FLAG ?
1465 KVASER_USB_HYDRA_CF_FLAG_EXTENDED_ID : 0);
1467 if (cf->can_id & CAN_RTR_FLAG)
1468 flags |= KVASER_USB_HYDRA_CF_FLAG_REMOTE_FRAME;
1470 flags |= (cf->can_id & CAN_ERR_FLAG ?
1471 KVASER_USB_HYDRA_CF_FLAG_ERROR_FRAME : 0);
1473 cmd->tx_can.id = cpu_to_le32(id);
1474 cmd->tx_can.flags = flags;
1476 memcpy(cmd->tx_can.data, cf->data, *frame_len);
1481 static int kvaser_usb_hydra_set_mode(struct net_device *netdev,
1487 case CAN_MODE_START:
1488 /* CAN controller automatically recovers from BUS_OFF */
1497 static int kvaser_usb_hydra_set_bittiming(struct net_device *netdev)
1499 struct kvaser_cmd *cmd;
1500 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1501 struct can_bittiming *bt = &priv->can.bittiming;
1502 struct kvaser_usb *dev = priv->dev;
1503 int tseg1 = bt->prop_seg + bt->phase_seg1;
1504 int tseg2 = bt->phase_seg2;
1508 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1512 cmd->header.cmd_no = CMD_SET_BUSPARAMS_REQ;
1513 cmd->set_busparams_req.bitrate = cpu_to_le32(bt->bitrate);
1514 cmd->set_busparams_req.sjw = (u8)sjw;
1515 cmd->set_busparams_req.tseg1 = (u8)tseg1;
1516 cmd->set_busparams_req.tseg2 = (u8)tseg2;
1517 cmd->set_busparams_req.nsamples = 1;
1519 kvaser_usb_hydra_set_cmd_dest_he
1520 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1521 kvaser_usb_hydra_set_cmd_transid
1522 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1524 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1531 static int kvaser_usb_hydra_set_data_bittiming(struct net_device *netdev)
1533 struct kvaser_cmd *cmd;
1534 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1535 struct can_bittiming *dbt = &priv->can.data_bittiming;
1536 struct kvaser_usb *dev = priv->dev;
1537 int tseg1 = dbt->prop_seg + dbt->phase_seg1;
1538 int tseg2 = dbt->phase_seg2;
1542 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1546 cmd->header.cmd_no = CMD_SET_BUSPARAMS_FD_REQ;
1547 cmd->set_busparams_req.bitrate_d = cpu_to_le32(dbt->bitrate);
1548 cmd->set_busparams_req.sjw_d = (u8)sjw;
1549 cmd->set_busparams_req.tseg1_d = (u8)tseg1;
1550 cmd->set_busparams_req.tseg2_d = (u8)tseg2;
1551 cmd->set_busparams_req.nsamples_d = 1;
1553 if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1554 if (priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)
1555 cmd->set_busparams_req.canfd_mode =
1556 KVASER_USB_HYDRA_BUS_MODE_NONISO;
1558 cmd->set_busparams_req.canfd_mode =
1559 KVASER_USB_HYDRA_BUS_MODE_CANFD_ISO;
1562 kvaser_usb_hydra_set_cmd_dest_he
1563 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1564 kvaser_usb_hydra_set_cmd_transid
1565 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1567 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1574 static int kvaser_usb_hydra_get_berr_counter(const struct net_device *netdev,
1575 struct can_berr_counter *bec)
1577 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1580 err = kvaser_usb_hydra_send_simple_cmd(priv->dev,
1581 CMD_GET_CHIP_STATE_REQ,
1591 static int kvaser_usb_hydra_setup_endpoints(struct kvaser_usb *dev)
1593 const struct usb_host_interface *iface_desc;
1594 struct usb_endpoint_descriptor *ep;
1597 iface_desc = dev->intf->cur_altsetting;
1599 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1600 ep = &iface_desc->endpoint[i].desc;
1602 if (!dev->bulk_in && usb_endpoint_is_bulk_in(ep) &&
1603 ep->bEndpointAddress == KVASER_USB_HYDRA_BULK_EP_IN_ADDR)
1606 if (!dev->bulk_out && usb_endpoint_is_bulk_out(ep) &&
1607 ep->bEndpointAddress == KVASER_USB_HYDRA_BULK_EP_OUT_ADDR)
1610 if (dev->bulk_in && dev->bulk_out)
1617 static int kvaser_usb_hydra_init_card(struct kvaser_usb *dev)
1621 struct kvaser_usb_dev_card_data_hydra *card_data =
1622 &dev->card_data.hydra;
1624 card_data->transid = KVASER_USB_HYDRA_MIN_TRANSID;
1625 spin_lock_init(&card_data->transid_lock);
1627 memset(card_data->usb_rx_leftover, 0, KVASER_USB_HYDRA_MAX_CMD_LEN);
1628 card_data->usb_rx_leftover_len = 0;
1629 spin_lock_init(&card_data->usb_rx_leftover_lock);
1631 memset(card_data->channel_to_he, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL,
1632 sizeof(card_data->channel_to_he));
1633 card_data->sysdbg_he = 0;
1635 for (i = 0; i < KVASER_USB_MAX_NET_DEVICES; i++) {
1636 err = kvaser_usb_hydra_map_channel
1638 (KVASER_USB_HYDRA_TRANSID_CANHE | i),
1641 dev_err(&dev->intf->dev,
1642 "CMD_MAP_CHANNEL_REQ failed for CAN%u\n", i);
1647 err = kvaser_usb_hydra_map_channel(dev, KVASER_USB_HYDRA_TRANSID_SYSDBG,
1650 dev_err(&dev->intf->dev,
1651 "CMD_MAP_CHANNEL_REQ failed for SYSDBG\n");
1658 static int kvaser_usb_hydra_get_software_info(struct kvaser_usb *dev)
1660 struct kvaser_cmd cmd;
1663 err = kvaser_usb_hydra_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO_REQ,
1668 memset(&cmd, 0, sizeof(struct kvaser_cmd));
1669 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_RESP, &cmd);
1673 dev->max_tx_urbs = min_t(unsigned int, KVASER_USB_MAX_TX_URBS,
1674 le16_to_cpu(cmd.sw_info.max_outstanding_tx));
1679 static int kvaser_usb_hydra_get_software_details(struct kvaser_usb *dev)
1681 struct kvaser_cmd *cmd;
1684 struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
1686 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1690 cmd->header.cmd_no = CMD_GET_SOFTWARE_DETAILS_REQ;
1691 cmd->sw_detail_req.use_ext_cmd = 1;
1692 kvaser_usb_hydra_set_cmd_dest_he
1693 (cmd, KVASER_USB_HYDRA_HE_ADDRESS_ILLEGAL);
1695 kvaser_usb_hydra_set_cmd_transid
1696 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1698 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1702 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_SOFTWARE_DETAILS_RESP,
1707 dev->fw_version = le32_to_cpu(cmd->sw_detail_res.sw_version);
1708 flags = le32_to_cpu(cmd->sw_detail_res.sw_flags);
1710 if (flags & KVASER_USB_HYDRA_SW_FLAG_FW_BAD) {
1711 dev_err(&dev->intf->dev,
1712 "Bad firmware, device refuse to run!\n");
1717 if (flags & KVASER_USB_HYDRA_SW_FLAG_FW_BETA)
1718 dev_info(&dev->intf->dev, "Beta firmware in use\n");
1720 if (flags & KVASER_USB_HYDRA_SW_FLAG_EXT_CAP)
1721 card_data->capabilities |= KVASER_USB_CAP_EXT_CAP;
1723 if (flags & KVASER_USB_HYDRA_SW_FLAG_EXT_CMD)
1724 card_data->capabilities |= KVASER_USB_HYDRA_CAP_EXT_CMD;
1726 if (flags & KVASER_USB_HYDRA_SW_FLAG_CANFD)
1727 card_data->ctrlmode_supported |= CAN_CTRLMODE_FD;
1729 if (flags & KVASER_USB_HYDRA_SW_FLAG_NONISO)
1730 card_data->ctrlmode_supported |= CAN_CTRLMODE_FD_NON_ISO;
1732 if (flags & KVASER_USB_HYDRA_SW_FLAG_FREQ_80M)
1733 dev->cfg = &kvaser_usb_hydra_dev_cfg_kcan;
1735 dev->cfg = &kvaser_usb_hydra_dev_cfg_flexc;
1743 static int kvaser_usb_hydra_get_card_info(struct kvaser_usb *dev)
1745 struct kvaser_cmd cmd;
1748 err = kvaser_usb_hydra_send_simple_cmd(dev, CMD_GET_CARD_INFO_REQ, -1);
1752 memset(&cmd, 0, sizeof(struct kvaser_cmd));
1753 err = kvaser_usb_hydra_wait_cmd(dev, CMD_GET_CARD_INFO_RESP, &cmd);
1757 dev->nchannels = cmd.card_info.nchannels;
1758 if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES)
1764 static int kvaser_usb_hydra_get_capabilities(struct kvaser_usb *dev)
1769 if (!(dev->card_data.capabilities & KVASER_USB_CAP_EXT_CAP)) {
1770 dev_info(&dev->intf->dev,
1771 "No extended capability support. Upgrade your device.\n");
1775 err = kvaser_usb_hydra_get_single_capability
1777 KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE,
1782 dev_info(&dev->intf->dev,
1783 "KVASER_USB_HYDRA_CAP_CMD_LISTEN_MODE failed %u\n",
1786 err = kvaser_usb_hydra_get_single_capability
1788 KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT,
1793 dev_info(&dev->intf->dev,
1794 "KVASER_USB_HYDRA_CAP_CMD_ERR_REPORT failed %u\n",
1797 err = kvaser_usb_hydra_get_single_capability
1798 (dev, KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT,
1803 dev_info(&dev->intf->dev,
1804 "KVASER_USB_HYDRA_CAP_CMD_ONE_SHOT failed %u\n",
1810 static int kvaser_usb_hydra_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1812 struct kvaser_usb *dev = priv->dev;
1813 struct kvaser_cmd *cmd;
1816 if ((priv->can.ctrlmode &
1817 (CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO)) ==
1818 CAN_CTRLMODE_FD_NON_ISO) {
1819 netdev_warn(priv->netdev,
1820 "CTRLMODE_FD shall be on if CTRLMODE_FD_NON_ISO is on\n");
1824 cmd = kcalloc(1, sizeof(struct kvaser_cmd), GFP_KERNEL);
1828 cmd->header.cmd_no = CMD_SET_DRIVERMODE_REQ;
1829 kvaser_usb_hydra_set_cmd_dest_he
1830 (cmd, dev->card_data.hydra.channel_to_he[priv->channel]);
1831 kvaser_usb_hydra_set_cmd_transid
1832 (cmd, kvaser_usb_hydra_get_next_transid(dev));
1833 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1834 cmd->set_ctrlmode.mode = KVASER_USB_HYDRA_CTRLMODE_LISTEN;
1836 cmd->set_ctrlmode.mode = KVASER_USB_HYDRA_CTRLMODE_NORMAL;
1838 err = kvaser_usb_send_cmd(dev, cmd, kvaser_usb_hydra_cmd_size(cmd));
1844 static int kvaser_usb_hydra_start_chip(struct kvaser_usb_net_priv *priv)
1848 init_completion(&priv->start_comp);
1850 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_START_CHIP_REQ,
1855 if (!wait_for_completion_timeout(&priv->start_comp,
1856 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1862 static int kvaser_usb_hydra_stop_chip(struct kvaser_usb_net_priv *priv)
1866 init_completion(&priv->stop_comp);
1868 /* Make sure we do not report invalid BUS_OFF from CMD_CHIP_STATE_EVENT
1869 * see comment in kvaser_usb_hydra_update_state()
1871 priv->can.state = CAN_STATE_STOPPED;
1873 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_STOP_CHIP_REQ,
1878 if (!wait_for_completion_timeout(&priv->stop_comp,
1879 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1885 static int kvaser_usb_hydra_flush_queue(struct kvaser_usb_net_priv *priv)
1889 reinit_completion(&priv->flush_comp);
1891 err = kvaser_usb_hydra_send_simple_cmd(priv->dev, CMD_FLUSH_QUEUE,
1896 if (!wait_for_completion_timeout(&priv->flush_comp,
1897 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1903 /* A single extended hydra command can be transmitted in multiple transfers
1904 * We have to buffer partial hydra commands, and handle them on next callback.
1906 static void kvaser_usb_hydra_read_bulk_callback(struct kvaser_usb *dev,
1909 unsigned long irq_flags;
1910 struct kvaser_cmd *cmd;
1913 struct kvaser_usb_dev_card_data_hydra *card_data =
1914 &dev->card_data.hydra;
1915 int usb_rx_leftover_len;
1916 spinlock_t *usb_rx_leftover_lock = &card_data->usb_rx_leftover_lock;
1918 spin_lock_irqsave(usb_rx_leftover_lock, irq_flags);
1919 usb_rx_leftover_len = card_data->usb_rx_leftover_len;
1920 if (usb_rx_leftover_len) {
1921 int remaining_bytes;
1923 cmd = (struct kvaser_cmd *)card_data->usb_rx_leftover;
1925 cmd_len = kvaser_usb_hydra_cmd_size(cmd);
1927 remaining_bytes = min_t(unsigned int, len,
1928 cmd_len - usb_rx_leftover_len);
1929 /* Make sure we do not overflow usb_rx_leftover */
1930 if (remaining_bytes + usb_rx_leftover_len >
1931 KVASER_USB_HYDRA_MAX_CMD_LEN) {
1932 dev_err(&dev->intf->dev, "Format error\n");
1933 spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags);
1937 memcpy(card_data->usb_rx_leftover + usb_rx_leftover_len, buf,
1939 pos += remaining_bytes;
1941 if (remaining_bytes + usb_rx_leftover_len == cmd_len) {
1942 kvaser_usb_hydra_handle_cmd(dev, cmd);
1943 usb_rx_leftover_len = 0;
1945 /* Command still not complete */
1946 usb_rx_leftover_len += remaining_bytes;
1948 card_data->usb_rx_leftover_len = usb_rx_leftover_len;
1950 spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags);
1955 cmd_len = kvaser_usb_hydra_cmd_size(cmd);
1957 if (pos + cmd_len > len) {
1958 /* We got first part of a command */
1961 leftover_bytes = len - pos;
1962 /* Make sure we do not overflow usb_rx_leftover */
1963 if (leftover_bytes > KVASER_USB_HYDRA_MAX_CMD_LEN) {
1964 dev_err(&dev->intf->dev, "Format error\n");
1967 spin_lock_irqsave(usb_rx_leftover_lock, irq_flags);
1968 memcpy(card_data->usb_rx_leftover, buf + pos,
1970 card_data->usb_rx_leftover_len = leftover_bytes;
1971 spin_unlock_irqrestore(usb_rx_leftover_lock, irq_flags);
1975 kvaser_usb_hydra_handle_cmd(dev, cmd);
1981 kvaser_usb_hydra_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
1982 const struct sk_buff *skb, int *frame_len,
1983 int *cmd_len, u16 transid)
1987 if (priv->dev->card_data.capabilities & KVASER_USB_HYDRA_CAP_EXT_CMD)
1988 buf = kvaser_usb_hydra_frame_to_cmd_ext(priv, skb, frame_len,
1991 buf = kvaser_usb_hydra_frame_to_cmd_std(priv, skb, frame_len,
1997 const struct kvaser_usb_dev_ops kvaser_usb_hydra_dev_ops = {
1998 .dev_set_mode = kvaser_usb_hydra_set_mode,
1999 .dev_set_bittiming = kvaser_usb_hydra_set_bittiming,
2000 .dev_set_data_bittiming = kvaser_usb_hydra_set_data_bittiming,
2001 .dev_get_berr_counter = kvaser_usb_hydra_get_berr_counter,
2002 .dev_setup_endpoints = kvaser_usb_hydra_setup_endpoints,
2003 .dev_init_card = kvaser_usb_hydra_init_card,
2004 .dev_get_software_info = kvaser_usb_hydra_get_software_info,
2005 .dev_get_software_details = kvaser_usb_hydra_get_software_details,
2006 .dev_get_card_info = kvaser_usb_hydra_get_card_info,
2007 .dev_get_capabilities = kvaser_usb_hydra_get_capabilities,
2008 .dev_set_opt_mode = kvaser_usb_hydra_set_opt_mode,
2009 .dev_start_chip = kvaser_usb_hydra_start_chip,
2010 .dev_stop_chip = kvaser_usb_hydra_stop_chip,
2011 .dev_reset_chip = NULL,
2012 .dev_flush_queue = kvaser_usb_hydra_flush_queue,
2013 .dev_read_bulk_callback = kvaser_usb_hydra_read_bulk_callback,
2014 .dev_frame_to_cmd = kvaser_usb_hydra_frame_to_cmd,
2017 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_kcan = {
2021 .timestamp_freq = 80,
2022 .bittiming_const = &kvaser_usb_hydra_kcan_bittiming_c,
2023 .data_bittiming_const = &kvaser_usb_hydra_kcan_bittiming_c,
2026 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_flexc = {
2030 .timestamp_freq = 1,
2031 .bittiming_const = &kvaser_usb_flexc_bittiming_const,