1 // SPDX-License-Identifier: GPL-2.0
2 /* Parts of this driver are based on the following:
3  *  - Kvaser linux leaf driver (version 4.78)
4  *  - CAN driver for esd CAN-USB/2
5  *  - Kvaser linux usbcanII driver (version 5.3)
6  *
7  * Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved.
8  * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
9  * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
10  * Copyright (C) 2015 Valeo S.A.
11  */
12 
13 #include <linux/completion.h>
14 #include <linux/device.h>
15 #include <linux/gfp.h>
16 #include <linux/jiffies.h>
17 #include <linux/kernel.h>
18 #include <linux/netdevice.h>
19 #include <linux/spinlock.h>
20 #include <linux/string.h>
21 #include <linux/types.h>
22 #include <linux/units.h>
23 #include <linux/usb.h>
24 #include <linux/workqueue.h>
25 
26 #include <linux/can.h>
27 #include <linux/can/dev.h>
28 #include <linux/can/error.h>
29 #include <linux/can/netlink.h>
30 
31 #include "kvaser_usb.h"
32 
33 #define MAX_USBCAN_NET_DEVICES		2
34 
35 /* Command header size */
36 #define CMD_HEADER_LEN			2
37 
38 /* Kvaser CAN message flags */
39 #define MSG_FLAG_ERROR_FRAME		BIT(0)
40 #define MSG_FLAG_OVERRUN		BIT(1)
41 #define MSG_FLAG_NERR			BIT(2)
42 #define MSG_FLAG_WAKEUP			BIT(3)
43 #define MSG_FLAG_REMOTE_FRAME		BIT(4)
44 #define MSG_FLAG_RESERVED		BIT(5)
45 #define MSG_FLAG_TX_ACK			BIT(6)
46 #define MSG_FLAG_TX_REQUEST		BIT(7)
47 
48 /* CAN states (M16C CxSTRH register) */
49 #define M16C_STATE_BUS_RESET		BIT(0)
50 #define M16C_STATE_BUS_ERROR		BIT(4)
51 #define M16C_STATE_BUS_PASSIVE		BIT(5)
52 #define M16C_STATE_BUS_OFF		BIT(6)
53 
54 /* Leaf/usbcan command ids */
55 #define CMD_RX_STD_MESSAGE		12
56 #define CMD_TX_STD_MESSAGE		13
57 #define CMD_RX_EXT_MESSAGE		14
58 #define CMD_TX_EXT_MESSAGE		15
59 #define CMD_SET_BUS_PARAMS		16
60 #define CMD_GET_BUS_PARAMS		17
61 #define CMD_GET_BUS_PARAMS_REPLY	18
62 #define CMD_GET_CHIP_STATE		19
63 #define CMD_CHIP_STATE_EVENT		20
64 #define CMD_SET_CTRL_MODE		21
65 #define CMD_RESET_CHIP			24
66 #define CMD_START_CHIP			26
67 #define CMD_START_CHIP_REPLY		27
68 #define CMD_STOP_CHIP			28
69 #define CMD_STOP_CHIP_REPLY		29
70 
71 #define CMD_USBCAN_CLOCK_OVERFLOW_EVENT	33
72 
73 #define CMD_GET_CARD_INFO		34
74 #define CMD_GET_CARD_INFO_REPLY		35
75 #define CMD_GET_SOFTWARE_INFO		38
76 #define CMD_GET_SOFTWARE_INFO_REPLY	39
77 #define CMD_ERROR_EVENT			45
78 #define CMD_FLUSH_QUEUE			48
79 #define CMD_TX_ACKNOWLEDGE		50
80 #define CMD_CAN_ERROR_EVENT		51
81 #define CMD_FLUSH_QUEUE_REPLY		68
82 #define CMD_GET_CAPABILITIES_REQ	95
83 #define CMD_GET_CAPABILITIES_RESP	96
84 
85 #define CMD_LEAF_LOG_MESSAGE		106
86 
87 /* Leaf frequency options */
88 #define KVASER_USB_LEAF_SWOPTION_FREQ_MASK 0x60
89 #define KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK 0
90 #define KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK BIT(5)
91 #define KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK BIT(6)
92 
93 #define KVASER_USB_LEAF_SWOPTION_EXT_CAP BIT(12)
94 
95 /* error factors */
96 #define M16C_EF_ACKE			BIT(0)
97 #define M16C_EF_CRCE			BIT(1)
98 #define M16C_EF_FORME			BIT(2)
99 #define M16C_EF_STFE			BIT(3)
100 #define M16C_EF_BITE0			BIT(4)
101 #define M16C_EF_BITE1			BIT(5)
102 #define M16C_EF_RCVE			BIT(6)
103 #define M16C_EF_TRE			BIT(7)
104 
105 /* Only Leaf-based devices can report M16C error factors,
106  * thus define our own error status flags for USBCANII
107  */
108 #define USBCAN_ERROR_STATE_NONE		0
109 #define USBCAN_ERROR_STATE_TX_ERROR	BIT(0)
110 #define USBCAN_ERROR_STATE_RX_ERROR	BIT(1)
111 #define USBCAN_ERROR_STATE_BUSERROR	BIT(2)
112 
113 /* ctrl modes */
114 #define KVASER_CTRL_MODE_NORMAL		1
115 #define KVASER_CTRL_MODE_SILENT		2
116 #define KVASER_CTRL_MODE_SELFRECEPTION	3
117 #define KVASER_CTRL_MODE_OFF		4
118 
119 /* Extended CAN identifier flag */
120 #define KVASER_EXTENDED_FRAME		BIT(31)
121 
122 struct kvaser_cmd_simple {
123 	u8 tid;
124 	u8 channel;
125 } __packed;
126 
127 struct kvaser_cmd_cardinfo {
128 	u8 tid;
129 	u8 nchannels;
130 	__le32 serial_number;
131 	__le32 padding0;
132 	__le32 clock_resolution;
133 	__le32 mfgdate;
134 	u8 ean[8];
135 	u8 hw_revision;
136 	union {
137 		struct {
138 			u8 usb_hs_mode;
139 		} __packed leaf1;
140 		struct {
141 			u8 padding;
142 		} __packed usbcan1;
143 	} __packed;
144 	__le16 padding1;
145 } __packed;
146 
147 struct leaf_cmd_softinfo {
148 	u8 tid;
149 	u8 padding0;
150 	__le32 sw_options;
151 	__le32 fw_version;
152 	__le16 max_outstanding_tx;
153 	__le16 padding1[9];
154 } __packed;
155 
156 struct usbcan_cmd_softinfo {
157 	u8 tid;
158 	u8 fw_name[5];
159 	__le16 max_outstanding_tx;
160 	u8 padding[6];
161 	__le32 fw_version;
162 	__le16 checksum;
163 	__le16 sw_options;
164 } __packed;
165 
166 struct kvaser_cmd_busparams {
167 	u8 tid;
168 	u8 channel;
169 	struct kvaser_usb_busparams busparams;
170 } __packed;
171 
172 struct kvaser_cmd_tx_can {
173 	u8 channel;
174 	u8 tid;
175 	u8 data[14];
176 	union {
177 		struct {
178 			u8 padding;
179 			u8 flags;
180 		} __packed leaf;
181 		struct {
182 			u8 flags;
183 			u8 padding;
184 		} __packed usbcan;
185 	} __packed;
186 } __packed;
187 
188 struct kvaser_cmd_rx_can_header {
189 	u8 channel;
190 	u8 flag;
191 } __packed;
192 
193 struct leaf_cmd_rx_can {
194 	u8 channel;
195 	u8 flag;
196 
197 	__le16 time[3];
198 	u8 data[14];
199 } __packed;
200 
201 struct usbcan_cmd_rx_can {
202 	u8 channel;
203 	u8 flag;
204 
205 	u8 data[14];
206 	__le16 time;
207 } __packed;
208 
209 struct leaf_cmd_chip_state_event {
210 	u8 tid;
211 	u8 channel;
212 
213 	__le16 time[3];
214 	u8 tx_errors_count;
215 	u8 rx_errors_count;
216 
217 	u8 status;
218 	u8 padding[3];
219 } __packed;
220 
221 struct usbcan_cmd_chip_state_event {
222 	u8 tid;
223 	u8 channel;
224 
225 	u8 tx_errors_count;
226 	u8 rx_errors_count;
227 	__le16 time;
228 
229 	u8 status;
230 	u8 padding[3];
231 } __packed;
232 
233 struct kvaser_cmd_tx_acknowledge_header {
234 	u8 channel;
235 	u8 tid;
236 } __packed;
237 
238 struct leaf_cmd_can_error_event {
239 	u8 tid;
240 	u8 flags;
241 	__le16 time[3];
242 	u8 channel;
243 	u8 padding;
244 	u8 tx_errors_count;
245 	u8 rx_errors_count;
246 	u8 status;
247 	u8 error_factor;
248 } __packed;
249 
250 struct usbcan_cmd_can_error_event {
251 	u8 tid;
252 	u8 padding;
253 	u8 tx_errors_count_ch0;
254 	u8 rx_errors_count_ch0;
255 	u8 tx_errors_count_ch1;
256 	u8 rx_errors_count_ch1;
257 	u8 status_ch0;
258 	u8 status_ch1;
259 	__le16 time;
260 } __packed;
261 
262 /* CMD_ERROR_EVENT error codes */
263 #define KVASER_USB_LEAF_ERROR_EVENT_TX_QUEUE_FULL 0x8
264 #define KVASER_USB_LEAF_ERROR_EVENT_PARAM 0x9
265 
266 struct leaf_cmd_error_event {
267 	u8 tid;
268 	u8 error_code;
269 	__le16 timestamp[3];
270 	__le16 padding;
271 	__le16 info1;
272 	__le16 info2;
273 } __packed;
274 
275 struct usbcan_cmd_error_event {
276 	u8 tid;
277 	u8 error_code;
278 	__le16 info1;
279 	__le16 info2;
280 	__le16 timestamp;
281 	__le16 padding;
282 } __packed;
283 
284 struct kvaser_cmd_ctrl_mode {
285 	u8 tid;
286 	u8 channel;
287 	u8 ctrl_mode;
288 	u8 padding[3];
289 } __packed;
290 
291 struct kvaser_cmd_flush_queue {
292 	u8 tid;
293 	u8 channel;
294 	u8 flags;
295 	u8 padding[3];
296 } __packed;
297 
298 struct leaf_cmd_log_message {
299 	u8 channel;
300 	u8 flags;
301 	__le16 time[3];
302 	u8 dlc;
303 	u8 time_offset;
304 	__le32 id;
305 	u8 data[8];
306 } __packed;
307 
308 /* Sub commands for cap_req and cap_res */
309 #define KVASER_USB_LEAF_CAP_CMD_LISTEN_MODE 0x02
310 #define KVASER_USB_LEAF_CAP_CMD_ERR_REPORT 0x05
311 struct kvaser_cmd_cap_req {
312 	__le16 padding0;
313 	__le16 cap_cmd;
314 	__le16 padding1;
315 	__le16 channel;
316 } __packed;
317 
318 /* Status codes for cap_res */
319 #define KVASER_USB_LEAF_CAP_STAT_OK 0x00
320 #define KVASER_USB_LEAF_CAP_STAT_NOT_IMPL 0x01
321 #define KVASER_USB_LEAF_CAP_STAT_UNAVAIL 0x02
322 struct kvaser_cmd_cap_res {
323 	__le16 padding;
324 	__le16 cap_cmd;
325 	__le16 status;
326 	__le32 mask;
327 	__le32 value;
328 } __packed;
329 
330 struct kvaser_cmd {
331 	u8 len;
332 	u8 id;
333 	union	{
334 		struct kvaser_cmd_simple simple;
335 		struct kvaser_cmd_cardinfo cardinfo;
336 		struct kvaser_cmd_busparams busparams;
337 
338 		struct kvaser_cmd_rx_can_header rx_can_header;
339 		struct kvaser_cmd_tx_acknowledge_header tx_acknowledge_header;
340 
341 		union {
342 			struct leaf_cmd_softinfo softinfo;
343 			struct leaf_cmd_rx_can rx_can;
344 			struct leaf_cmd_chip_state_event chip_state_event;
345 			struct leaf_cmd_can_error_event can_error_event;
346 			struct leaf_cmd_log_message log_message;
347 			struct leaf_cmd_error_event error_event;
348 			struct kvaser_cmd_cap_req cap_req;
349 			struct kvaser_cmd_cap_res cap_res;
350 		} __packed leaf;
351 
352 		union {
353 			struct usbcan_cmd_softinfo softinfo;
354 			struct usbcan_cmd_rx_can rx_can;
355 			struct usbcan_cmd_chip_state_event chip_state_event;
356 			struct usbcan_cmd_can_error_event can_error_event;
357 			struct usbcan_cmd_error_event error_event;
358 		} __packed usbcan;
359 
360 		struct kvaser_cmd_tx_can tx_can;
361 		struct kvaser_cmd_ctrl_mode ctrl_mode;
362 		struct kvaser_cmd_flush_queue flush_queue;
363 	} u;
364 } __packed;
365 
366 #define CMD_SIZE_ANY 0xff
367 #define kvaser_fsize(field) sizeof_field(struct kvaser_cmd, field)
368 
369 static const u8 kvaser_usb_leaf_cmd_sizes_leaf[] = {
370 	[CMD_START_CHIP_REPLY]		= kvaser_fsize(u.simple),
371 	[CMD_STOP_CHIP_REPLY]		= kvaser_fsize(u.simple),
372 	[CMD_GET_CARD_INFO_REPLY]	= kvaser_fsize(u.cardinfo),
373 	[CMD_TX_ACKNOWLEDGE]		= kvaser_fsize(u.tx_acknowledge_header),
374 	[CMD_GET_SOFTWARE_INFO_REPLY]	= kvaser_fsize(u.leaf.softinfo),
375 	[CMD_RX_STD_MESSAGE]		= kvaser_fsize(u.leaf.rx_can),
376 	[CMD_RX_EXT_MESSAGE]		= kvaser_fsize(u.leaf.rx_can),
377 	[CMD_LEAF_LOG_MESSAGE]		= kvaser_fsize(u.leaf.log_message),
378 	[CMD_CHIP_STATE_EVENT]		= kvaser_fsize(u.leaf.chip_state_event),
379 	[CMD_CAN_ERROR_EVENT]		= kvaser_fsize(u.leaf.can_error_event),
380 	[CMD_GET_CAPABILITIES_RESP]	= kvaser_fsize(u.leaf.cap_res),
381 	[CMD_GET_BUS_PARAMS_REPLY]	= kvaser_fsize(u.busparams),
382 	[CMD_ERROR_EVENT]		= kvaser_fsize(u.leaf.error_event),
383 	/* ignored events: */
384 	[CMD_FLUSH_QUEUE_REPLY]		= CMD_SIZE_ANY,
385 };
386 
387 static const u8 kvaser_usb_leaf_cmd_sizes_usbcan[] = {
388 	[CMD_START_CHIP_REPLY]		= kvaser_fsize(u.simple),
389 	[CMD_STOP_CHIP_REPLY]		= kvaser_fsize(u.simple),
390 	[CMD_GET_CARD_INFO_REPLY]	= kvaser_fsize(u.cardinfo),
391 	[CMD_TX_ACKNOWLEDGE]		= kvaser_fsize(u.tx_acknowledge_header),
392 	[CMD_GET_SOFTWARE_INFO_REPLY]	= kvaser_fsize(u.usbcan.softinfo),
393 	[CMD_RX_STD_MESSAGE]		= kvaser_fsize(u.usbcan.rx_can),
394 	[CMD_RX_EXT_MESSAGE]		= kvaser_fsize(u.usbcan.rx_can),
395 	[CMD_CHIP_STATE_EVENT]		= kvaser_fsize(u.usbcan.chip_state_event),
396 	[CMD_CAN_ERROR_EVENT]		= kvaser_fsize(u.usbcan.can_error_event),
397 	[CMD_ERROR_EVENT]		= kvaser_fsize(u.usbcan.error_event),
398 	/* ignored events: */
399 	[CMD_USBCAN_CLOCK_OVERFLOW_EVENT] = CMD_SIZE_ANY,
400 };
401 
402 /* Summary of a kvaser error event, for a unified Leaf/Usbcan error
403  * handling. Some discrepancies between the two families exist:
404  *
405  * - USBCAN firmware does not report M16C "error factors"
406  * - USBCAN controllers has difficulties reporting if the raised error
407  *   event is for ch0 or ch1. They leave such arbitration to the OS
408  *   driver by letting it compare error counters with previous values
409  *   and decide the error event's channel. Thus for USBCAN, the channel
410  *   field is only advisory.
411  */
412 struct kvaser_usb_err_summary {
413 	u8 channel, status, txerr, rxerr;
414 	union {
415 		struct {
416 			u8 error_factor;
417 		} leaf;
418 		struct {
419 			u8 other_ch_status;
420 			u8 error_state;
421 		} usbcan;
422 	};
423 };
424 
425 struct kvaser_usb_net_leaf_priv {
426 	struct kvaser_usb_net_priv *net;
427 
428 	struct delayed_work chip_state_req_work;
429 
430 	/* started but not reported as bus-on yet */
431 	bool joining_bus;
432 };
433 
434 static const struct can_bittiming_const kvaser_usb_leaf_m16c_bittiming_const = {
435 	.name = "kvaser_usb_ucii",
436 	.tseg1_min = 4,
437 	.tseg1_max = 16,
438 	.tseg2_min = 2,
439 	.tseg2_max = 8,
440 	.sjw_max = 4,
441 	.brp_min = 1,
442 	.brp_max = 16,
443 	.brp_inc = 1,
444 };
445 
446 static const struct can_bittiming_const kvaser_usb_leaf_m32c_bittiming_const = {
447 	.name = "kvaser_usb_leaf",
448 	.tseg1_min = 3,
449 	.tseg1_max = 16,
450 	.tseg2_min = 2,
451 	.tseg2_max = 8,
452 	.sjw_max = 4,
453 	.brp_min = 2,
454 	.brp_max = 128,
455 	.brp_inc = 2,
456 };
457 
458 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_usbcan_dev_cfg = {
459 	.clock = {
460 		.freq = 8 * MEGA /* Hz */,
461 	},
462 	.timestamp_freq = 1,
463 	.bittiming_const = &kvaser_usb_leaf_m16c_bittiming_const,
464 };
465 
466 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_m32c_dev_cfg = {
467 	.clock = {
468 		.freq = 16 * MEGA /* Hz */,
469 	},
470 	.timestamp_freq = 1,
471 	.bittiming_const = &kvaser_usb_leaf_m32c_bittiming_const,
472 };
473 
474 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_16mhz = {
475 	.clock = {
476 		.freq = 16 * MEGA /* Hz */,
477 	},
478 	.timestamp_freq = 1,
479 	.bittiming_const = &kvaser_usb_flexc_bittiming_const,
480 };
481 
482 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_24mhz = {
483 	.clock = {
484 		.freq = 24 * MEGA /* Hz */,
485 	},
486 	.timestamp_freq = 1,
487 	.bittiming_const = &kvaser_usb_flexc_bittiming_const,
488 };
489 
490 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_32mhz = {
491 	.clock = {
492 		.freq = 32 * MEGA /* Hz */,
493 	},
494 	.timestamp_freq = 1,
495 	.bittiming_const = &kvaser_usb_flexc_bittiming_const,
496 };
497 
498 static int kvaser_usb_leaf_verify_size(const struct kvaser_usb *dev,
499 				       const struct kvaser_cmd *cmd)
500 {
501 	/* buffer size >= cmd->len ensured by caller */
502 	u8 min_size = 0;
503 
504 	switch (dev->driver_info->family) {
505 	case KVASER_LEAF:
506 		if (cmd->id < ARRAY_SIZE(kvaser_usb_leaf_cmd_sizes_leaf))
507 			min_size = kvaser_usb_leaf_cmd_sizes_leaf[cmd->id];
508 		break;
509 	case KVASER_USBCAN:
510 		if (cmd->id < ARRAY_SIZE(kvaser_usb_leaf_cmd_sizes_usbcan))
511 			min_size = kvaser_usb_leaf_cmd_sizes_usbcan[cmd->id];
512 		break;
513 	}
514 
515 	if (min_size == CMD_SIZE_ANY)
516 		return 0;
517 
518 	if (min_size) {
519 		min_size += CMD_HEADER_LEN;
520 		if (cmd->len >= min_size)
521 			return 0;
522 
523 		dev_err_ratelimited(&dev->intf->dev,
524 				    "Received command %u too short (size %u, needed %u)",
525 				    cmd->id, cmd->len, min_size);
526 		return -EIO;
527 	}
528 
529 	dev_warn_ratelimited(&dev->intf->dev,
530 			     "Unhandled command (%d, size %d)\n",
531 			     cmd->id, cmd->len);
532 	return -EINVAL;
533 }
534 
535 static void *
536 kvaser_usb_leaf_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
537 			     const struct sk_buff *skb, int *cmd_len,
538 			     u16 transid)
539 {
540 	struct kvaser_usb *dev = priv->dev;
541 	struct kvaser_cmd *cmd;
542 	u8 *cmd_tx_can_flags = NULL;		/* GCC */
543 	struct can_frame *cf = (struct can_frame *)skb->data;
544 
545 	cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
546 	if (cmd) {
547 		cmd->u.tx_can.tid = transid & 0xff;
548 		cmd->len = *cmd_len = CMD_HEADER_LEN +
549 				      sizeof(struct kvaser_cmd_tx_can);
550 		cmd->u.tx_can.channel = priv->channel;
551 
552 		switch (dev->driver_info->family) {
553 		case KVASER_LEAF:
554 			cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags;
555 			break;
556 		case KVASER_USBCAN:
557 			cmd_tx_can_flags = &cmd->u.tx_can.usbcan.flags;
558 			break;
559 		}
560 
561 		*cmd_tx_can_flags = 0;
562 
563 		if (cf->can_id & CAN_EFF_FLAG) {
564 			cmd->id = CMD_TX_EXT_MESSAGE;
565 			cmd->u.tx_can.data[0] = (cf->can_id >> 24) & 0x1f;
566 			cmd->u.tx_can.data[1] = (cf->can_id >> 18) & 0x3f;
567 			cmd->u.tx_can.data[2] = (cf->can_id >> 14) & 0x0f;
568 			cmd->u.tx_can.data[3] = (cf->can_id >> 6) & 0xff;
569 			cmd->u.tx_can.data[4] = cf->can_id & 0x3f;
570 		} else {
571 			cmd->id = CMD_TX_STD_MESSAGE;
572 			cmd->u.tx_can.data[0] = (cf->can_id >> 6) & 0x1f;
573 			cmd->u.tx_can.data[1] = cf->can_id & 0x3f;
574 		}
575 
576 		cmd->u.tx_can.data[5] = can_get_cc_dlc(cf, priv->can.ctrlmode);
577 		memcpy(&cmd->u.tx_can.data[6], cf->data, cf->len);
578 
579 		if (cf->can_id & CAN_RTR_FLAG)
580 			*cmd_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
581 	}
582 	return cmd;
583 }
584 
585 static int kvaser_usb_leaf_wait_cmd(const struct kvaser_usb *dev, u8 id,
586 				    struct kvaser_cmd *cmd)
587 {
588 	struct kvaser_cmd *tmp;
589 	void *buf;
590 	int actual_len;
591 	int err;
592 	int pos;
593 	unsigned long to = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT);
594 
595 	buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL);
596 	if (!buf)
597 		return -ENOMEM;
598 
599 	do {
600 		err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE,
601 					  &actual_len);
602 		if (err < 0)
603 			goto end;
604 
605 		pos = 0;
606 		while (pos <= actual_len - CMD_HEADER_LEN) {
607 			tmp = buf + pos;
608 
609 			/* Handle commands crossing the USB endpoint max packet
610 			 * size boundary. Check kvaser_usb_read_bulk_callback()
611 			 * for further details.
612 			 */
613 			if (tmp->len == 0) {
614 				pos = round_up(pos,
615 					       le16_to_cpu
616 						(dev->bulk_in->wMaxPacketSize));
617 				continue;
618 			}
619 
620 			if (pos + tmp->len > actual_len) {
621 				dev_err_ratelimited(&dev->intf->dev,
622 						    "Format error\n");
623 				break;
624 			}
625 
626 			if (tmp->id == id) {
627 				memcpy(cmd, tmp, tmp->len);
628 				goto end;
629 			}
630 
631 			pos += tmp->len;
632 		}
633 	} while (time_before(jiffies, to));
634 
635 	err = -EINVAL;
636 
637 end:
638 	kfree(buf);
639 
640 	if (err == 0)
641 		err = kvaser_usb_leaf_verify_size(dev, cmd);
642 
643 	return err;
644 }
645 
646 static int kvaser_usb_leaf_send_simple_cmd(const struct kvaser_usb *dev,
647 					   u8 cmd_id, int channel)
648 {
649 	struct kvaser_cmd *cmd;
650 	int rc;
651 
652 	cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
653 	if (!cmd)
654 		return -ENOMEM;
655 
656 	cmd->id = cmd_id;
657 	cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
658 	cmd->u.simple.channel = channel;
659 	cmd->u.simple.tid = 0xff;
660 
661 	rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
662 
663 	kfree(cmd);
664 	return rc;
665 }
666 
667 static void kvaser_usb_leaf_get_software_info_leaf(struct kvaser_usb *dev,
668 						   const struct leaf_cmd_softinfo *softinfo)
669 {
670 	u32 sw_options = le32_to_cpu(softinfo->sw_options);
671 
672 	dev->fw_version = le32_to_cpu(softinfo->fw_version);
673 	dev->max_tx_urbs = le16_to_cpu(softinfo->max_outstanding_tx);
674 
675 	if (sw_options & KVASER_USB_LEAF_SWOPTION_EXT_CAP)
676 		dev->card_data.capabilities |= KVASER_USB_CAP_EXT_CAP;
677 
678 	if (dev->driver_info->quirks & KVASER_USB_QUIRK_IGNORE_CLK_FREQ) {
679 		/* Firmware expects bittiming parameters calculated for 16MHz
680 		 * clock, regardless of the actual clock
681 		 */
682 		dev->cfg = &kvaser_usb_leaf_m32c_dev_cfg;
683 	} else {
684 		switch (sw_options & KVASER_USB_LEAF_SWOPTION_FREQ_MASK) {
685 		case KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK:
686 			dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_16mhz;
687 			break;
688 		case KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK:
689 			dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_24mhz;
690 			break;
691 		case KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK:
692 			dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_32mhz;
693 			break;
694 		}
695 	}
696 }
697 
698 static int kvaser_usb_leaf_get_software_info_inner(struct kvaser_usb *dev)
699 {
700 	struct kvaser_cmd cmd;
701 	int err;
702 
703 	err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO, 0);
704 	if (err)
705 		return err;
706 
707 	err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_REPLY, &cmd);
708 	if (err)
709 		return err;
710 
711 	switch (dev->driver_info->family) {
712 	case KVASER_LEAF:
713 		kvaser_usb_leaf_get_software_info_leaf(dev, &cmd.u.leaf.softinfo);
714 		break;
715 	case KVASER_USBCAN:
716 		dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version);
717 		dev->max_tx_urbs =
718 			le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx);
719 		dev->cfg = &kvaser_usb_leaf_usbcan_dev_cfg;
720 		break;
721 	}
722 
723 	return 0;
724 }
725 
726 static int kvaser_usb_leaf_get_software_info(struct kvaser_usb *dev)
727 {
728 	int err;
729 	int retry = 3;
730 
731 	/* On some x86 laptops, plugging a Kvaser device again after
732 	 * an unplug makes the firmware always ignore the very first
733 	 * command. For such a case, provide some room for retries
734 	 * instead of completely exiting the driver.
735 	 */
736 	do {
737 		err = kvaser_usb_leaf_get_software_info_inner(dev);
738 	} while (--retry && err == -ETIMEDOUT);
739 
740 	return err;
741 }
742 
743 static int kvaser_usb_leaf_get_card_info(struct kvaser_usb *dev)
744 {
745 	struct kvaser_cmd cmd;
746 	int err;
747 
748 	err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_CARD_INFO, 0);
749 	if (err)
750 		return err;
751 
752 	err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_CARD_INFO_REPLY, &cmd);
753 	if (err)
754 		return err;
755 
756 	dev->nchannels = cmd.u.cardinfo.nchannels;
757 	if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES ||
758 	    (dev->driver_info->family == KVASER_USBCAN &&
759 	     dev->nchannels > MAX_USBCAN_NET_DEVICES))
760 		return -EINVAL;
761 
762 	return 0;
763 }
764 
765 static int kvaser_usb_leaf_get_single_capability(struct kvaser_usb *dev,
766 						 u16 cap_cmd_req, u16 *status)
767 {
768 	struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
769 	struct kvaser_cmd *cmd;
770 	u32 value = 0;
771 	u32 mask = 0;
772 	u16 cap_cmd_res;
773 	int err;
774 	int i;
775 
776 	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
777 	if (!cmd)
778 		return -ENOMEM;
779 
780 	cmd->id = CMD_GET_CAPABILITIES_REQ;
781 	cmd->u.leaf.cap_req.cap_cmd = cpu_to_le16(cap_cmd_req);
782 	cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_cap_req);
783 
784 	err = kvaser_usb_send_cmd(dev, cmd, cmd->len);
785 	if (err)
786 		goto end;
787 
788 	err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_CAPABILITIES_RESP, cmd);
789 	if (err)
790 		goto end;
791 
792 	*status = le16_to_cpu(cmd->u.leaf.cap_res.status);
793 
794 	if (*status != KVASER_USB_LEAF_CAP_STAT_OK)
795 		goto end;
796 
797 	cap_cmd_res = le16_to_cpu(cmd->u.leaf.cap_res.cap_cmd);
798 	switch (cap_cmd_res) {
799 	case KVASER_USB_LEAF_CAP_CMD_LISTEN_MODE:
800 	case KVASER_USB_LEAF_CAP_CMD_ERR_REPORT:
801 		value = le32_to_cpu(cmd->u.leaf.cap_res.value);
802 		mask = le32_to_cpu(cmd->u.leaf.cap_res.mask);
803 		break;
804 	default:
805 		dev_warn(&dev->intf->dev, "Unknown capability command %u\n",
806 			 cap_cmd_res);
807 		break;
808 	}
809 
810 	for (i = 0; i < dev->nchannels; i++) {
811 		if (BIT(i) & (value & mask)) {
812 			switch (cap_cmd_res) {
813 			case KVASER_USB_LEAF_CAP_CMD_LISTEN_MODE:
814 				card_data->ctrlmode_supported |=
815 						CAN_CTRLMODE_LISTENONLY;
816 				break;
817 			case KVASER_USB_LEAF_CAP_CMD_ERR_REPORT:
818 				card_data->capabilities |=
819 						KVASER_USB_CAP_BERR_CAP;
820 				break;
821 			}
822 		}
823 	}
824 
825 end:
826 	kfree(cmd);
827 
828 	return err;
829 }
830 
831 static int kvaser_usb_leaf_get_capabilities_leaf(struct kvaser_usb *dev)
832 {
833 	int err;
834 	u16 status;
835 
836 	if (!(dev->card_data.capabilities & KVASER_USB_CAP_EXT_CAP)) {
837 		dev_info(&dev->intf->dev,
838 			 "No extended capability support. Upgrade device firmware.\n");
839 		return 0;
840 	}
841 
842 	err = kvaser_usb_leaf_get_single_capability(dev,
843 						    KVASER_USB_LEAF_CAP_CMD_LISTEN_MODE,
844 						    &status);
845 	if (err)
846 		return err;
847 	if (status)
848 		dev_info(&dev->intf->dev,
849 			 "KVASER_USB_LEAF_CAP_CMD_LISTEN_MODE failed %u\n",
850 			 status);
851 
852 	err = kvaser_usb_leaf_get_single_capability(dev,
853 						    KVASER_USB_LEAF_CAP_CMD_ERR_REPORT,
854 						    &status);
855 	if (err)
856 		return err;
857 	if (status)
858 		dev_info(&dev->intf->dev,
859 			 "KVASER_USB_LEAF_CAP_CMD_ERR_REPORT failed %u\n",
860 			 status);
861 
862 	return 0;
863 }
864 
865 static int kvaser_usb_leaf_get_capabilities(struct kvaser_usb *dev)
866 {
867 	int err = 0;
868 
869 	if (dev->driver_info->family == KVASER_LEAF)
870 		err = kvaser_usb_leaf_get_capabilities_leaf(dev);
871 
872 	return err;
873 }
874 
875 static void kvaser_usb_leaf_tx_acknowledge(const struct kvaser_usb *dev,
876 					   const struct kvaser_cmd *cmd)
877 {
878 	struct net_device_stats *stats;
879 	struct kvaser_usb_tx_urb_context *context;
880 	struct kvaser_usb_net_priv *priv;
881 	unsigned long flags;
882 	u8 channel, tid;
883 
884 	channel = cmd->u.tx_acknowledge_header.channel;
885 	tid = cmd->u.tx_acknowledge_header.tid;
886 
887 	if (channel >= dev->nchannels) {
888 		dev_err(&dev->intf->dev,
889 			"Invalid channel number (%d)\n", channel);
890 		return;
891 	}
892 
893 	priv = dev->nets[channel];
894 
895 	if (!netif_device_present(priv->netdev))
896 		return;
897 
898 	stats = &priv->netdev->stats;
899 
900 	context = &priv->tx_contexts[tid % dev->max_tx_urbs];
901 
902 	/* Sometimes the state change doesn't come after a bus-off event */
903 	if (priv->can.restart_ms && priv->can.state == CAN_STATE_BUS_OFF) {
904 		struct sk_buff *skb;
905 		struct can_frame *cf;
906 
907 		skb = alloc_can_err_skb(priv->netdev, &cf);
908 		if (skb) {
909 			cf->can_id |= CAN_ERR_RESTARTED;
910 
911 			netif_rx(skb);
912 		} else {
913 			netdev_err(priv->netdev,
914 				   "No memory left for err_skb\n");
915 		}
916 
917 		priv->can.can_stats.restarts++;
918 		netif_carrier_on(priv->netdev);
919 
920 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
921 	}
922 
923 	spin_lock_irqsave(&priv->tx_contexts_lock, flags);
924 
925 	stats->tx_packets++;
926 	stats->tx_bytes += can_get_echo_skb(priv->netdev,
927 					    context->echo_index, NULL);
928 	context->echo_index = dev->max_tx_urbs;
929 	--priv->active_tx_contexts;
930 	netif_wake_queue(priv->netdev);
931 
932 	spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
933 }
934 
935 static int kvaser_usb_leaf_simple_cmd_async(struct kvaser_usb_net_priv *priv,
936 					    u8 cmd_id)
937 {
938 	struct kvaser_cmd *cmd;
939 	int err;
940 
941 	cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
942 	if (!cmd)
943 		return -ENOMEM;
944 
945 	cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
946 	cmd->id = cmd_id;
947 	cmd->u.simple.channel = priv->channel;
948 
949 	err = kvaser_usb_send_cmd_async(priv, cmd, cmd->len);
950 	if (err)
951 		kfree(cmd);
952 
953 	return err;
954 }
955 
956 static void kvaser_usb_leaf_chip_state_req_work(struct work_struct *work)
957 {
958 	struct kvaser_usb_net_leaf_priv *leaf =
959 		container_of(work, struct kvaser_usb_net_leaf_priv,
960 			     chip_state_req_work.work);
961 	struct kvaser_usb_net_priv *priv = leaf->net;
962 
963 	kvaser_usb_leaf_simple_cmd_async(priv, CMD_GET_CHIP_STATE);
964 }
965 
966 static void
967 kvaser_usb_leaf_rx_error_update_can_state(struct kvaser_usb_net_priv *priv,
968 					const struct kvaser_usb_err_summary *es,
969 					struct can_frame *cf)
970 {
971 	struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;
972 	struct kvaser_usb *dev = priv->dev;
973 	struct net_device_stats *stats = &priv->netdev->stats;
974 	enum can_state cur_state, new_state, tx_state, rx_state;
975 
976 	netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status);
977 
978 	new_state = priv->can.state;
979 	cur_state = priv->can.state;
980 
981 	if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
982 		new_state = CAN_STATE_BUS_OFF;
983 	} else if (es->status & M16C_STATE_BUS_PASSIVE) {
984 		new_state = CAN_STATE_ERROR_PASSIVE;
985 	} else if ((es->status & M16C_STATE_BUS_ERROR) &&
986 		   cur_state >= CAN_STATE_BUS_OFF) {
987 		/* Guard against spurious error events after a busoff */
988 	} else if (es->txerr >= 128 || es->rxerr >= 128) {
989 		new_state = CAN_STATE_ERROR_PASSIVE;
990 	} else if (es->txerr >= 96 || es->rxerr >= 96) {
991 		new_state = CAN_STATE_ERROR_WARNING;
992 	} else {
993 		new_state = CAN_STATE_ERROR_ACTIVE;
994 	}
995 
996 	/* 0bfd:0124 FW 4.18.778 was observed to send the initial
997 	 * CMD_CHIP_STATE_EVENT after CMD_START_CHIP with M16C_STATE_BUS_OFF
998 	 * bit set if the channel was bus-off when it was last stopped (even
999 	 * across chip resets). This bit will clear shortly afterwards, without
1000 	 * triggering a second unsolicited chip state event.
1001 	 * Ignore this initial bus-off.
1002 	 */
1003 	if (leaf->joining_bus) {
1004 		if (new_state == CAN_STATE_BUS_OFF) {
1005 			netdev_dbg(priv->netdev, "ignoring bus-off during startup");
1006 			new_state = cur_state;
1007 		} else {
1008 			leaf->joining_bus = false;
1009 		}
1010 	}
1011 
1012 	if (new_state != cur_state) {
1013 		tx_state = (es->txerr >= es->rxerr) ? new_state : 0;
1014 		rx_state = (es->txerr <= es->rxerr) ? new_state : 0;
1015 
1016 		can_change_state(priv->netdev, cf, tx_state, rx_state);
1017 	}
1018 
1019 	if (priv->can.restart_ms &&
1020 	    cur_state == CAN_STATE_BUS_OFF &&
1021 	    new_state < CAN_STATE_BUS_OFF)
1022 		priv->can.can_stats.restarts++;
1023 
1024 	switch (dev->driver_info->family) {
1025 	case KVASER_LEAF:
1026 		if (es->leaf.error_factor) {
1027 			priv->can.can_stats.bus_error++;
1028 			stats->rx_errors++;
1029 		}
1030 		break;
1031 	case KVASER_USBCAN:
1032 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR)
1033 			stats->tx_errors++;
1034 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR)
1035 			stats->rx_errors++;
1036 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
1037 			priv->can.can_stats.bus_error++;
1038 		break;
1039 	}
1040 
1041 	priv->bec.txerr = es->txerr;
1042 	priv->bec.rxerr = es->rxerr;
1043 }
1044 
1045 static void kvaser_usb_leaf_rx_error(const struct kvaser_usb *dev,
1046 				     const struct kvaser_usb_err_summary *es)
1047 {
1048 	struct can_frame *cf;
1049 	struct can_frame tmp_cf = { .can_id = CAN_ERR_FLAG,
1050 				    .len = CAN_ERR_DLC };
1051 	struct sk_buff *skb;
1052 	struct net_device_stats *stats;
1053 	struct kvaser_usb_net_priv *priv;
1054 	struct kvaser_usb_net_leaf_priv *leaf;
1055 	enum can_state old_state, new_state;
1056 
1057 	if (es->channel >= dev->nchannels) {
1058 		dev_err(&dev->intf->dev,
1059 			"Invalid channel number (%d)\n", es->channel);
1060 		return;
1061 	}
1062 
1063 	priv = dev->nets[es->channel];
1064 	leaf = priv->sub_priv;
1065 	stats = &priv->netdev->stats;
1066 
1067 	/* Ignore e.g. state change to bus-off reported just after stopping */
1068 	if (!netif_running(priv->netdev))
1069 		return;
1070 
1071 	/* Update all of the CAN interface's state and error counters before
1072 	 * trying any memory allocation that can actually fail with -ENOMEM.
1073 	 *
1074 	 * We send a temporary stack-allocated error CAN frame to
1075 	 * can_change_state() for the very same reason.
1076 	 *
1077 	 * TODO: Split can_change_state() responsibility between updating the
1078 	 * CAN interface's state and counters, and the setting up of CAN error
1079 	 * frame ID and data to userspace. Remove stack allocation afterwards.
1080 	 */
1081 	old_state = priv->can.state;
1082 	kvaser_usb_leaf_rx_error_update_can_state(priv, es, &tmp_cf);
1083 	new_state = priv->can.state;
1084 
1085 	/* If there are errors, request status updates periodically as we do
1086 	 * not get automatic notifications of improved state.
1087 	 * Also request updates if we saw a stale BUS_OFF during startup
1088 	 * (joining_bus).
1089 	 */
1090 	if (new_state < CAN_STATE_BUS_OFF &&
1091 	    (es->rxerr || es->txerr || new_state == CAN_STATE_ERROR_PASSIVE ||
1092 	     leaf->joining_bus))
1093 		schedule_delayed_work(&leaf->chip_state_req_work,
1094 				      msecs_to_jiffies(500));
1095 
1096 	skb = alloc_can_err_skb(priv->netdev, &cf);
1097 	if (!skb) {
1098 		stats->rx_dropped++;
1099 		return;
1100 	}
1101 	memcpy(cf, &tmp_cf, sizeof(*cf));
1102 
1103 	if (new_state != old_state) {
1104 		if (es->status &
1105 		    (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
1106 			if (!priv->can.restart_ms)
1107 				kvaser_usb_leaf_simple_cmd_async(priv,
1108 								 CMD_STOP_CHIP);
1109 			netif_carrier_off(priv->netdev);
1110 		}
1111 
1112 		if (priv->can.restart_ms &&
1113 		    old_state == CAN_STATE_BUS_OFF &&
1114 		    new_state < CAN_STATE_BUS_OFF) {
1115 			cf->can_id |= CAN_ERR_RESTARTED;
1116 			netif_carrier_on(priv->netdev);
1117 		}
1118 	}
1119 
1120 	switch (dev->driver_info->family) {
1121 	case KVASER_LEAF:
1122 		if (es->leaf.error_factor) {
1123 			cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
1124 
1125 			if (es->leaf.error_factor & M16C_EF_ACKE)
1126 				cf->data[3] = CAN_ERR_PROT_LOC_ACK;
1127 			if (es->leaf.error_factor & M16C_EF_CRCE)
1128 				cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
1129 			if (es->leaf.error_factor & M16C_EF_FORME)
1130 				cf->data[2] |= CAN_ERR_PROT_FORM;
1131 			if (es->leaf.error_factor & M16C_EF_STFE)
1132 				cf->data[2] |= CAN_ERR_PROT_STUFF;
1133 			if (es->leaf.error_factor & M16C_EF_BITE0)
1134 				cf->data[2] |= CAN_ERR_PROT_BIT0;
1135 			if (es->leaf.error_factor & M16C_EF_BITE1)
1136 				cf->data[2] |= CAN_ERR_PROT_BIT1;
1137 			if (es->leaf.error_factor & M16C_EF_TRE)
1138 				cf->data[2] |= CAN_ERR_PROT_TX;
1139 		}
1140 		break;
1141 	case KVASER_USBCAN:
1142 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
1143 			cf->can_id |= CAN_ERR_BUSERROR;
1144 		break;
1145 	}
1146 
1147 	if (new_state != CAN_STATE_BUS_OFF) {
1148 		cf->can_id |= CAN_ERR_CNT;
1149 		cf->data[6] = es->txerr;
1150 		cf->data[7] = es->rxerr;
1151 	}
1152 
1153 	netif_rx(skb);
1154 }
1155 
1156 /* For USBCAN, report error to userspace if the channels's errors counter
1157  * has changed, or we're the only channel seeing a bus error state.
1158  */
1159 static void
1160 kvaser_usb_leaf_usbcan_conditionally_rx_error(const struct kvaser_usb *dev,
1161 					      struct kvaser_usb_err_summary *es)
1162 {
1163 	struct kvaser_usb_net_priv *priv;
1164 	unsigned int channel;
1165 	bool report_error;
1166 
1167 	channel = es->channel;
1168 	if (channel >= dev->nchannels) {
1169 		dev_err(&dev->intf->dev,
1170 			"Invalid channel number (%d)\n", channel);
1171 		return;
1172 	}
1173 
1174 	priv = dev->nets[channel];
1175 	report_error = false;
1176 
1177 	if (es->txerr != priv->bec.txerr) {
1178 		es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR;
1179 		report_error = true;
1180 	}
1181 	if (es->rxerr != priv->bec.rxerr) {
1182 		es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR;
1183 		report_error = true;
1184 	}
1185 	if ((es->status & M16C_STATE_BUS_ERROR) &&
1186 	    !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) {
1187 		es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR;
1188 		report_error = true;
1189 	}
1190 
1191 	if (report_error)
1192 		kvaser_usb_leaf_rx_error(dev, es);
1193 }
1194 
1195 static void kvaser_usb_leaf_usbcan_rx_error(const struct kvaser_usb *dev,
1196 					    const struct kvaser_cmd *cmd)
1197 {
1198 	struct kvaser_usb_err_summary es = { };
1199 
1200 	switch (cmd->id) {
1201 	/* Sometimes errors are sent as unsolicited chip state events */
1202 	case CMD_CHIP_STATE_EVENT:
1203 		es.channel = cmd->u.usbcan.chip_state_event.channel;
1204 		es.status = cmd->u.usbcan.chip_state_event.status;
1205 		es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count;
1206 		es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count;
1207 		kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
1208 		break;
1209 
1210 	case CMD_CAN_ERROR_EVENT:
1211 		es.channel = 0;
1212 		es.status = cmd->u.usbcan.can_error_event.status_ch0;
1213 		es.txerr = cmd->u.usbcan.can_error_event.tx_errors_count_ch0;
1214 		es.rxerr = cmd->u.usbcan.can_error_event.rx_errors_count_ch0;
1215 		es.usbcan.other_ch_status =
1216 			cmd->u.usbcan.can_error_event.status_ch1;
1217 		kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
1218 
1219 		/* The USBCAN firmware supports up to 2 channels.
1220 		 * Now that ch0 was checked, check if ch1 has any errors.
1221 		 */
1222 		if (dev->nchannels == MAX_USBCAN_NET_DEVICES) {
1223 			es.channel = 1;
1224 			es.status = cmd->u.usbcan.can_error_event.status_ch1;
1225 			es.txerr =
1226 				cmd->u.usbcan.can_error_event.tx_errors_count_ch1;
1227 			es.rxerr =
1228 				cmd->u.usbcan.can_error_event.rx_errors_count_ch1;
1229 			es.usbcan.other_ch_status =
1230 				cmd->u.usbcan.can_error_event.status_ch0;
1231 			kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
1232 		}
1233 		break;
1234 
1235 	default:
1236 		dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
1237 	}
1238 }
1239 
1240 static void kvaser_usb_leaf_leaf_rx_error(const struct kvaser_usb *dev,
1241 					  const struct kvaser_cmd *cmd)
1242 {
1243 	struct kvaser_usb_err_summary es = { };
1244 
1245 	switch (cmd->id) {
1246 	case CMD_CAN_ERROR_EVENT:
1247 		es.channel = cmd->u.leaf.can_error_event.channel;
1248 		es.status = cmd->u.leaf.can_error_event.status;
1249 		es.txerr = cmd->u.leaf.can_error_event.tx_errors_count;
1250 		es.rxerr = cmd->u.leaf.can_error_event.rx_errors_count;
1251 		es.leaf.error_factor = cmd->u.leaf.can_error_event.error_factor;
1252 		break;
1253 	case CMD_LEAF_LOG_MESSAGE:
1254 		es.channel = cmd->u.leaf.log_message.channel;
1255 		es.status = cmd->u.leaf.log_message.data[0];
1256 		es.txerr = cmd->u.leaf.log_message.data[2];
1257 		es.rxerr = cmd->u.leaf.log_message.data[3];
1258 		es.leaf.error_factor = cmd->u.leaf.log_message.data[1];
1259 		break;
1260 	case CMD_CHIP_STATE_EVENT:
1261 		es.channel = cmd->u.leaf.chip_state_event.channel;
1262 		es.status = cmd->u.leaf.chip_state_event.status;
1263 		es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;
1264 		es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;
1265 		es.leaf.error_factor = 0;
1266 		break;
1267 	default:
1268 		dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
1269 		return;
1270 	}
1271 
1272 	kvaser_usb_leaf_rx_error(dev, &es);
1273 }
1274 
1275 static void kvaser_usb_leaf_rx_can_err(const struct kvaser_usb_net_priv *priv,
1276 				       const struct kvaser_cmd *cmd)
1277 {
1278 	if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
1279 					 MSG_FLAG_NERR)) {
1280 		struct net_device_stats *stats = &priv->netdev->stats;
1281 
1282 		netdev_err(priv->netdev, "Unknown error (flags: 0x%02x)\n",
1283 			   cmd->u.rx_can_header.flag);
1284 
1285 		stats->rx_errors++;
1286 		return;
1287 	}
1288 
1289 	if (cmd->u.rx_can_header.flag & MSG_FLAG_OVERRUN)
1290 		kvaser_usb_can_rx_over_error(priv->netdev);
1291 }
1292 
1293 static void kvaser_usb_leaf_rx_can_msg(const struct kvaser_usb *dev,
1294 				       const struct kvaser_cmd *cmd)
1295 {
1296 	struct kvaser_usb_net_priv *priv;
1297 	struct can_frame *cf;
1298 	struct sk_buff *skb;
1299 	struct net_device_stats *stats;
1300 	u8 channel = cmd->u.rx_can_header.channel;
1301 	const u8 *rx_data = NULL;	/* GCC */
1302 
1303 	if (channel >= dev->nchannels) {
1304 		dev_err(&dev->intf->dev,
1305 			"Invalid channel number (%d)\n", channel);
1306 		return;
1307 	}
1308 
1309 	priv = dev->nets[channel];
1310 	stats = &priv->netdev->stats;
1311 
1312 	if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
1313 	    (dev->driver_info->family == KVASER_LEAF &&
1314 	     cmd->id == CMD_LEAF_LOG_MESSAGE)) {
1315 		kvaser_usb_leaf_leaf_rx_error(dev, cmd);
1316 		return;
1317 	} else if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
1318 						MSG_FLAG_NERR |
1319 						MSG_FLAG_OVERRUN)) {
1320 		kvaser_usb_leaf_rx_can_err(priv, cmd);
1321 		return;
1322 	} else if (cmd->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
1323 		netdev_warn(priv->netdev,
1324 			    "Unhandled frame (flags: 0x%02x)\n",
1325 			    cmd->u.rx_can_header.flag);
1326 		return;
1327 	}
1328 
1329 	switch (dev->driver_info->family) {
1330 	case KVASER_LEAF:
1331 		rx_data = cmd->u.leaf.rx_can.data;
1332 		break;
1333 	case KVASER_USBCAN:
1334 		rx_data = cmd->u.usbcan.rx_can.data;
1335 		break;
1336 	}
1337 
1338 	skb = alloc_can_skb(priv->netdev, &cf);
1339 	if (!skb) {
1340 		stats->rx_dropped++;
1341 		return;
1342 	}
1343 
1344 	if (dev->driver_info->family == KVASER_LEAF && cmd->id ==
1345 	    CMD_LEAF_LOG_MESSAGE) {
1346 		cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id);
1347 		if (cf->can_id & KVASER_EXTENDED_FRAME)
1348 			cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG;
1349 		else
1350 			cf->can_id &= CAN_SFF_MASK;
1351 
1352 		can_frame_set_cc_len(cf, cmd->u.leaf.log_message.dlc & 0xF, priv->can.ctrlmode);
1353 
1354 		if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
1355 			cf->can_id |= CAN_RTR_FLAG;
1356 		else
1357 			memcpy(cf->data, &cmd->u.leaf.log_message.data,
1358 			       cf->len);
1359 	} else {
1360 		cf->can_id = ((rx_data[0] & 0x1f) << 6) | (rx_data[1] & 0x3f);
1361 
1362 		if (cmd->id == CMD_RX_EXT_MESSAGE) {
1363 			cf->can_id <<= 18;
1364 			cf->can_id |= ((rx_data[2] & 0x0f) << 14) |
1365 				      ((rx_data[3] & 0xff) << 6) |
1366 				      (rx_data[4] & 0x3f);
1367 			cf->can_id |= CAN_EFF_FLAG;
1368 		}
1369 
1370 		can_frame_set_cc_len(cf, rx_data[5] & 0xF, priv->can.ctrlmode);
1371 
1372 		if (cmd->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
1373 			cf->can_id |= CAN_RTR_FLAG;
1374 		else
1375 			memcpy(cf->data, &rx_data[6], cf->len);
1376 	}
1377 
1378 	stats->rx_packets++;
1379 	if (!(cf->can_id & CAN_RTR_FLAG))
1380 		stats->rx_bytes += cf->len;
1381 	netif_rx(skb);
1382 }
1383 
1384 static void kvaser_usb_leaf_error_event_parameter(const struct kvaser_usb *dev,
1385 						  const struct kvaser_cmd *cmd)
1386 {
1387 	u16 info1 = 0;
1388 
1389 	switch (dev->driver_info->family) {
1390 	case KVASER_LEAF:
1391 		info1 = le16_to_cpu(cmd->u.leaf.error_event.info1);
1392 		break;
1393 	case KVASER_USBCAN:
1394 		info1 = le16_to_cpu(cmd->u.usbcan.error_event.info1);
1395 		break;
1396 	}
1397 
1398 	/* info1 will contain the offending cmd_no */
1399 	switch (info1) {
1400 	case CMD_SET_CTRL_MODE:
1401 		dev_warn(&dev->intf->dev,
1402 			 "CMD_SET_CTRL_MODE error in parameter\n");
1403 		break;
1404 
1405 	case CMD_SET_BUS_PARAMS:
1406 		dev_warn(&dev->intf->dev,
1407 			 "CMD_SET_BUS_PARAMS error in parameter\n");
1408 		break;
1409 
1410 	default:
1411 		dev_warn(&dev->intf->dev,
1412 			 "Unhandled parameter error event cmd_no (%u)\n",
1413 			 info1);
1414 		break;
1415 	}
1416 }
1417 
1418 static void kvaser_usb_leaf_error_event(const struct kvaser_usb *dev,
1419 					const struct kvaser_cmd *cmd)
1420 {
1421 	u8 error_code = 0;
1422 
1423 	switch (dev->driver_info->family) {
1424 	case KVASER_LEAF:
1425 		error_code = cmd->u.leaf.error_event.error_code;
1426 		break;
1427 	case KVASER_USBCAN:
1428 		error_code = cmd->u.usbcan.error_event.error_code;
1429 		break;
1430 	}
1431 
1432 	switch (error_code) {
1433 	case KVASER_USB_LEAF_ERROR_EVENT_TX_QUEUE_FULL:
1434 		/* Received additional CAN message, when firmware TX queue is
1435 		 * already full. Something is wrong with the driver.
1436 		 * This should never happen!
1437 		 */
1438 		dev_err(&dev->intf->dev,
1439 			"Received error event TX_QUEUE_FULL\n");
1440 		break;
1441 	case KVASER_USB_LEAF_ERROR_EVENT_PARAM:
1442 		kvaser_usb_leaf_error_event_parameter(dev, cmd);
1443 		break;
1444 
1445 	default:
1446 		dev_warn(&dev->intf->dev,
1447 			 "Unhandled error event (%d)\n", error_code);
1448 		break;
1449 	}
1450 }
1451 
1452 static void kvaser_usb_leaf_start_chip_reply(const struct kvaser_usb *dev,
1453 					     const struct kvaser_cmd *cmd)
1454 {
1455 	struct kvaser_usb_net_priv *priv;
1456 	u8 channel = cmd->u.simple.channel;
1457 
1458 	if (channel >= dev->nchannels) {
1459 		dev_err(&dev->intf->dev,
1460 			"Invalid channel number (%d)\n", channel);
1461 		return;
1462 	}
1463 
1464 	priv = dev->nets[channel];
1465 
1466 	if (completion_done(&priv->start_comp) &&
1467 	    netif_queue_stopped(priv->netdev)) {
1468 		netif_wake_queue(priv->netdev);
1469 	} else {
1470 		netif_start_queue(priv->netdev);
1471 		complete(&priv->start_comp);
1472 	}
1473 }
1474 
1475 static void kvaser_usb_leaf_stop_chip_reply(const struct kvaser_usb *dev,
1476 					    const struct kvaser_cmd *cmd)
1477 {
1478 	struct kvaser_usb_net_priv *priv;
1479 	u8 channel = cmd->u.simple.channel;
1480 
1481 	if (channel >= dev->nchannels) {
1482 		dev_err(&dev->intf->dev,
1483 			"Invalid channel number (%d)\n", channel);
1484 		return;
1485 	}
1486 
1487 	priv = dev->nets[channel];
1488 
1489 	complete(&priv->stop_comp);
1490 }
1491 
1492 static void kvaser_usb_leaf_get_busparams_reply(const struct kvaser_usb *dev,
1493 						const struct kvaser_cmd *cmd)
1494 {
1495 	struct kvaser_usb_net_priv *priv;
1496 	u8 channel = cmd->u.busparams.channel;
1497 
1498 	if (channel >= dev->nchannels) {
1499 		dev_err(&dev->intf->dev,
1500 			"Invalid channel number (%d)\n", channel);
1501 		return;
1502 	}
1503 
1504 	priv = dev->nets[channel];
1505 	memcpy(&priv->busparams_nominal, &cmd->u.busparams.busparams,
1506 	       sizeof(priv->busparams_nominal));
1507 
1508 	complete(&priv->get_busparams_comp);
1509 }
1510 
1511 static void kvaser_usb_leaf_handle_command(const struct kvaser_usb *dev,
1512 					   const struct kvaser_cmd *cmd)
1513 {
1514 	if (kvaser_usb_leaf_verify_size(dev, cmd) < 0)
1515 		return;
1516 
1517 	switch (cmd->id) {
1518 	case CMD_START_CHIP_REPLY:
1519 		kvaser_usb_leaf_start_chip_reply(dev, cmd);
1520 		break;
1521 
1522 	case CMD_STOP_CHIP_REPLY:
1523 		kvaser_usb_leaf_stop_chip_reply(dev, cmd);
1524 		break;
1525 
1526 	case CMD_RX_STD_MESSAGE:
1527 	case CMD_RX_EXT_MESSAGE:
1528 		kvaser_usb_leaf_rx_can_msg(dev, cmd);
1529 		break;
1530 
1531 	case CMD_LEAF_LOG_MESSAGE:
1532 		if (dev->driver_info->family != KVASER_LEAF)
1533 			goto warn;
1534 		kvaser_usb_leaf_rx_can_msg(dev, cmd);
1535 		break;
1536 
1537 	case CMD_CHIP_STATE_EVENT:
1538 	case CMD_CAN_ERROR_EVENT:
1539 		if (dev->driver_info->family == KVASER_LEAF)
1540 			kvaser_usb_leaf_leaf_rx_error(dev, cmd);
1541 		else
1542 			kvaser_usb_leaf_usbcan_rx_error(dev, cmd);
1543 		break;
1544 
1545 	case CMD_TX_ACKNOWLEDGE:
1546 		kvaser_usb_leaf_tx_acknowledge(dev, cmd);
1547 		break;
1548 
1549 	case CMD_ERROR_EVENT:
1550 		kvaser_usb_leaf_error_event(dev, cmd);
1551 		break;
1552 
1553 	case CMD_GET_BUS_PARAMS_REPLY:
1554 		kvaser_usb_leaf_get_busparams_reply(dev, cmd);
1555 		break;
1556 
1557 	/* Ignored commands */
1558 	case CMD_USBCAN_CLOCK_OVERFLOW_EVENT:
1559 		if (dev->driver_info->family != KVASER_USBCAN)
1560 			goto warn;
1561 		break;
1562 
1563 	case CMD_FLUSH_QUEUE_REPLY:
1564 		if (dev->driver_info->family != KVASER_LEAF)
1565 			goto warn;
1566 		break;
1567 
1568 	default:
1569 warn:		dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", cmd->id);
1570 		break;
1571 	}
1572 }
1573 
1574 static void kvaser_usb_leaf_read_bulk_callback(struct kvaser_usb *dev,
1575 					       void *buf, int len)
1576 {
1577 	struct kvaser_cmd *cmd;
1578 	int pos = 0;
1579 
1580 	while (pos <= len - CMD_HEADER_LEN) {
1581 		cmd = buf + pos;
1582 
1583 		/* The Kvaser firmware can only read and write commands that
1584 		 * does not cross the USB's endpoint wMaxPacketSize boundary.
1585 		 * If a follow-up command crosses such boundary, firmware puts
1586 		 * a placeholder zero-length command in its place then aligns
1587 		 * the real command to the next max packet size.
1588 		 *
1589 		 * Handle such cases or we're going to miss a significant
1590 		 * number of events in case of a heavy rx load on the bus.
1591 		 */
1592 		if (cmd->len == 0) {
1593 			pos = round_up(pos, le16_to_cpu
1594 						(dev->bulk_in->wMaxPacketSize));
1595 			continue;
1596 		}
1597 
1598 		if (pos + cmd->len > len) {
1599 			dev_err_ratelimited(&dev->intf->dev, "Format error\n");
1600 			break;
1601 		}
1602 
1603 		kvaser_usb_leaf_handle_command(dev, cmd);
1604 		pos += cmd->len;
1605 	}
1606 }
1607 
1608 static int kvaser_usb_leaf_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1609 {
1610 	struct kvaser_cmd *cmd;
1611 	int rc;
1612 
1613 	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1614 	if (!cmd)
1615 		return -ENOMEM;
1616 
1617 	cmd->id = CMD_SET_CTRL_MODE;
1618 	cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_ctrl_mode);
1619 	cmd->u.ctrl_mode.tid = 0xff;
1620 	cmd->u.ctrl_mode.channel = priv->channel;
1621 
1622 	if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1623 		cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1624 	else
1625 		cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1626 
1627 	rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1628 
1629 	kfree(cmd);
1630 	return rc;
1631 }
1632 
1633 static int kvaser_usb_leaf_start_chip(struct kvaser_usb_net_priv *priv)
1634 {
1635 	struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;
1636 	int err;
1637 
1638 	leaf->joining_bus = true;
1639 
1640 	reinit_completion(&priv->start_comp);
1641 
1642 	err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_START_CHIP,
1643 					      priv->channel);
1644 	if (err)
1645 		return err;
1646 
1647 	if (!wait_for_completion_timeout(&priv->start_comp,
1648 					 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1649 		return -ETIMEDOUT;
1650 
1651 	return 0;
1652 }
1653 
1654 static int kvaser_usb_leaf_stop_chip(struct kvaser_usb_net_priv *priv)
1655 {
1656 	struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;
1657 	int err;
1658 
1659 	reinit_completion(&priv->stop_comp);
1660 
1661 	cancel_delayed_work(&leaf->chip_state_req_work);
1662 
1663 	err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_STOP_CHIP,
1664 					      priv->channel);
1665 	if (err)
1666 		return err;
1667 
1668 	if (!wait_for_completion_timeout(&priv->stop_comp,
1669 					 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1670 		return -ETIMEDOUT;
1671 
1672 	return 0;
1673 }
1674 
1675 static int kvaser_usb_leaf_reset_chip(struct kvaser_usb *dev, int channel)
1676 {
1677 	return kvaser_usb_leaf_send_simple_cmd(dev, CMD_RESET_CHIP, channel);
1678 }
1679 
1680 static int kvaser_usb_leaf_flush_queue(struct kvaser_usb_net_priv *priv)
1681 {
1682 	struct kvaser_cmd *cmd;
1683 	int rc;
1684 
1685 	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1686 	if (!cmd)
1687 		return -ENOMEM;
1688 
1689 	cmd->id = CMD_FLUSH_QUEUE;
1690 	cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_flush_queue);
1691 	cmd->u.flush_queue.channel = priv->channel;
1692 	cmd->u.flush_queue.flags = 0x00;
1693 
1694 	rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1695 
1696 	kfree(cmd);
1697 	return rc;
1698 }
1699 
1700 static int kvaser_usb_leaf_init_card(struct kvaser_usb *dev)
1701 {
1702 	struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
1703 
1704 	card_data->ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1705 
1706 	return 0;
1707 }
1708 
1709 static int kvaser_usb_leaf_init_channel(struct kvaser_usb_net_priv *priv)
1710 {
1711 	struct kvaser_usb_net_leaf_priv *leaf;
1712 
1713 	leaf = devm_kzalloc(&priv->dev->intf->dev, sizeof(*leaf), GFP_KERNEL);
1714 	if (!leaf)
1715 		return -ENOMEM;
1716 
1717 	leaf->net = priv;
1718 	INIT_DELAYED_WORK(&leaf->chip_state_req_work,
1719 			  kvaser_usb_leaf_chip_state_req_work);
1720 
1721 	priv->sub_priv = leaf;
1722 
1723 	return 0;
1724 }
1725 
1726 static void kvaser_usb_leaf_remove_channel(struct kvaser_usb_net_priv *priv)
1727 {
1728 	struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;
1729 
1730 	if (leaf)
1731 		cancel_delayed_work_sync(&leaf->chip_state_req_work);
1732 }
1733 
1734 static int kvaser_usb_leaf_set_bittiming(const struct net_device *netdev,
1735 					 const struct kvaser_usb_busparams *busparams)
1736 {
1737 	struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1738 	struct kvaser_usb *dev = priv->dev;
1739 	struct kvaser_cmd *cmd;
1740 	int rc;
1741 
1742 	cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1743 	if (!cmd)
1744 		return -ENOMEM;
1745 
1746 	cmd->id = CMD_SET_BUS_PARAMS;
1747 	cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_busparams);
1748 	cmd->u.busparams.channel = priv->channel;
1749 	cmd->u.busparams.tid = 0xff;
1750 	memcpy(&cmd->u.busparams.busparams, busparams,
1751 	       sizeof(cmd->u.busparams.busparams));
1752 
1753 	rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
1754 
1755 	kfree(cmd);
1756 	return rc;
1757 }
1758 
1759 static int kvaser_usb_leaf_get_busparams(struct kvaser_usb_net_priv *priv)
1760 {
1761 	int err;
1762 
1763 	if (priv->dev->driver_info->family == KVASER_USBCAN)
1764 		return -EOPNOTSUPP;
1765 
1766 	reinit_completion(&priv->get_busparams_comp);
1767 
1768 	err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_GET_BUS_PARAMS,
1769 					      priv->channel);
1770 	if (err)
1771 		return err;
1772 
1773 	if (!wait_for_completion_timeout(&priv->get_busparams_comp,
1774 					 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1775 		return -ETIMEDOUT;
1776 
1777 	return 0;
1778 }
1779 
1780 static int kvaser_usb_leaf_set_mode(struct net_device *netdev,
1781 				    enum can_mode mode)
1782 {
1783 	struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1784 	struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;
1785 	int err;
1786 
1787 	switch (mode) {
1788 	case CAN_MODE_START:
1789 		kvaser_usb_unlink_tx_urbs(priv);
1790 
1791 		leaf->joining_bus = true;
1792 
1793 		err = kvaser_usb_leaf_simple_cmd_async(priv, CMD_START_CHIP);
1794 		if (err)
1795 			return err;
1796 
1797 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
1798 		break;
1799 	default:
1800 		return -EOPNOTSUPP;
1801 	}
1802 
1803 	return 0;
1804 }
1805 
1806 static int kvaser_usb_leaf_get_berr_counter(const struct net_device *netdev,
1807 					    struct can_berr_counter *bec)
1808 {
1809 	struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1810 
1811 	*bec = priv->bec;
1812 
1813 	return 0;
1814 }
1815 
1816 static int kvaser_usb_leaf_setup_endpoints(struct kvaser_usb *dev)
1817 {
1818 	const struct usb_host_interface *iface_desc;
1819 	struct usb_endpoint_descriptor *endpoint;
1820 	int i;
1821 
1822 	iface_desc = dev->intf->cur_altsetting;
1823 
1824 	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1825 		endpoint = &iface_desc->endpoint[i].desc;
1826 
1827 		if (!dev->bulk_in && usb_endpoint_is_bulk_in(endpoint))
1828 			dev->bulk_in = endpoint;
1829 
1830 		if (!dev->bulk_out && usb_endpoint_is_bulk_out(endpoint))
1831 			dev->bulk_out = endpoint;
1832 
1833 		/* use first bulk endpoint for in and out */
1834 		if (dev->bulk_in && dev->bulk_out)
1835 			return 0;
1836 	}
1837 
1838 	return -ENODEV;
1839 }
1840 
1841 const struct kvaser_usb_dev_ops kvaser_usb_leaf_dev_ops = {
1842 	.dev_set_mode = kvaser_usb_leaf_set_mode,
1843 	.dev_set_bittiming = kvaser_usb_leaf_set_bittiming,
1844 	.dev_get_busparams = kvaser_usb_leaf_get_busparams,
1845 	.dev_set_data_bittiming = NULL,
1846 	.dev_get_data_busparams = NULL,
1847 	.dev_get_berr_counter = kvaser_usb_leaf_get_berr_counter,
1848 	.dev_setup_endpoints = kvaser_usb_leaf_setup_endpoints,
1849 	.dev_init_card = kvaser_usb_leaf_init_card,
1850 	.dev_init_channel = kvaser_usb_leaf_init_channel,
1851 	.dev_remove_channel = kvaser_usb_leaf_remove_channel,
1852 	.dev_get_software_info = kvaser_usb_leaf_get_software_info,
1853 	.dev_get_software_details = NULL,
1854 	.dev_get_card_info = kvaser_usb_leaf_get_card_info,
1855 	.dev_get_capabilities = kvaser_usb_leaf_get_capabilities,
1856 	.dev_set_opt_mode = kvaser_usb_leaf_set_opt_mode,
1857 	.dev_start_chip = kvaser_usb_leaf_start_chip,
1858 	.dev_stop_chip = kvaser_usb_leaf_stop_chip,
1859 	.dev_reset_chip = kvaser_usb_leaf_reset_chip,
1860 	.dev_flush_queue = kvaser_usb_leaf_flush_queue,
1861 	.dev_read_bulk_callback = kvaser_usb_leaf_read_bulk_callback,
1862 	.dev_frame_to_cmd = kvaser_usb_leaf_frame_to_cmd,
1863 };
1864