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