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