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