1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
3  * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
4  *
5  * Copyright (C) 2016  PEAK System-Technik GmbH
6  */
7 
8 #include <linux/can.h>
9 #include <linux/can/dev.h>
10 #include <linux/ethtool.h>
11 
12 #include "peak_canfd_user.h"
13 
14 /* internal IP core cache size (used as default echo skbs max number) */
15 #define PCANFD_ECHO_SKB_MAX		24
16 
17 /* bittiming ranges of the PEAK-System PC CAN-FD interfaces */
18 static const struct can_bittiming_const peak_canfd_nominal_const = {
19 	.name = "peak_canfd",
20 	.tseg1_min = 1,
21 	.tseg1_max = (1 << PUCAN_TSLOW_TSGEG1_BITS),
22 	.tseg2_min = 1,
23 	.tseg2_max = (1 << PUCAN_TSLOW_TSGEG2_BITS),
24 	.sjw_max = (1 << PUCAN_TSLOW_SJW_BITS),
25 	.brp_min = 1,
26 	.brp_max = (1 << PUCAN_TSLOW_BRP_BITS),
27 	.brp_inc = 1,
28 };
29 
30 static const struct can_bittiming_const peak_canfd_data_const = {
31 	.name = "peak_canfd",
32 	.tseg1_min = 1,
33 	.tseg1_max = (1 << PUCAN_TFAST_TSGEG1_BITS),
34 	.tseg2_min = 1,
35 	.tseg2_max = (1 << PUCAN_TFAST_TSGEG2_BITS),
36 	.sjw_max = (1 << PUCAN_TFAST_SJW_BITS),
37 	.brp_min = 1,
38 	.brp_max = (1 << PUCAN_TFAST_BRP_BITS),
39 	.brp_inc = 1,
40 };
41 
42 static struct peak_canfd_priv *pucan_init_cmd(struct peak_canfd_priv *priv)
43 {
44 	priv->cmd_len = 0;
45 	return priv;
46 }
47 
48 static void *pucan_add_cmd(struct peak_canfd_priv *priv, int cmd_op)
49 {
50 	struct pucan_command *cmd;
51 
52 	if (priv->cmd_len + sizeof(*cmd) > priv->cmd_maxlen)
53 		return NULL;
54 
55 	cmd = priv->cmd_buffer + priv->cmd_len;
56 
57 	/* reset all unused bit to default */
58 	memset(cmd, 0, sizeof(*cmd));
59 
60 	cmd->opcode_channel = pucan_cmd_opcode_channel(priv->index, cmd_op);
61 	priv->cmd_len += sizeof(*cmd);
62 
63 	return cmd;
64 }
65 
66 static int pucan_write_cmd(struct peak_canfd_priv *priv)
67 {
68 	int err;
69 
70 	if (priv->pre_cmd) {
71 		err = priv->pre_cmd(priv);
72 		if (err)
73 			return err;
74 	}
75 
76 	err = priv->write_cmd(priv);
77 	if (err)
78 		return err;
79 
80 	if (priv->post_cmd)
81 		err = priv->post_cmd(priv);
82 
83 	return err;
84 }
85 
86 /* uCAN commands interface functions */
87 static int pucan_set_reset_mode(struct peak_canfd_priv *priv)
88 {
89 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_RESET_MODE);
90 	return pucan_write_cmd(priv);
91 }
92 
93 static int pucan_set_normal_mode(struct peak_canfd_priv *priv)
94 {
95 	int err;
96 
97 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_NORMAL_MODE);
98 	err = pucan_write_cmd(priv);
99 	if (!err)
100 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
101 
102 	return err;
103 }
104 
105 static int pucan_set_listen_only_mode(struct peak_canfd_priv *priv)
106 {
107 	int err;
108 
109 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_LISTEN_ONLY_MODE);
110 	err = pucan_write_cmd(priv);
111 	if (!err)
112 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
113 
114 	return err;
115 }
116 
117 static int pucan_set_timing_slow(struct peak_canfd_priv *priv,
118 				 const struct can_bittiming *pbt)
119 {
120 	struct pucan_timing_slow *cmd;
121 
122 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_TIMING_SLOW);
123 
124 	cmd->sjw_t = PUCAN_TSLOW_SJW_T(pbt->sjw - 1,
125 				       priv->can.ctrlmode &
126 				       CAN_CTRLMODE_3_SAMPLES);
127 	cmd->tseg1 = PUCAN_TSLOW_TSEG1(pbt->prop_seg + pbt->phase_seg1 - 1);
128 	cmd->tseg2 = PUCAN_TSLOW_TSEG2(pbt->phase_seg2 - 1);
129 	cmd->brp = cpu_to_le16(PUCAN_TSLOW_BRP(pbt->brp - 1));
130 
131 	cmd->ewl = 96;	/* default */
132 
133 	netdev_dbg(priv->ndev,
134 		   "nominal: brp=%u tseg1=%u tseg2=%u sjw=%u\n",
135 		   le16_to_cpu(cmd->brp), cmd->tseg1, cmd->tseg2, cmd->sjw_t);
136 
137 	return pucan_write_cmd(priv);
138 }
139 
140 static int pucan_set_timing_fast(struct peak_canfd_priv *priv,
141 				 const struct can_bittiming *pbt)
142 {
143 	struct pucan_timing_fast *cmd;
144 
145 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_TIMING_FAST);
146 
147 	cmd->sjw = PUCAN_TFAST_SJW(pbt->sjw - 1);
148 	cmd->tseg1 = PUCAN_TFAST_TSEG1(pbt->prop_seg + pbt->phase_seg1 - 1);
149 	cmd->tseg2 = PUCAN_TFAST_TSEG2(pbt->phase_seg2 - 1);
150 	cmd->brp = cpu_to_le16(PUCAN_TFAST_BRP(pbt->brp - 1));
151 
152 	netdev_dbg(priv->ndev,
153 		   "data: brp=%u tseg1=%u tseg2=%u sjw=%u\n",
154 		   le16_to_cpu(cmd->brp), cmd->tseg1, cmd->tseg2, cmd->sjw);
155 
156 	return pucan_write_cmd(priv);
157 }
158 
159 static int pucan_set_std_filter(struct peak_canfd_priv *priv, u8 row, u32 mask)
160 {
161 	struct pucan_std_filter *cmd;
162 
163 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_SET_STD_FILTER);
164 
165 	/* all the 11-bits CAN ID values are represented by one bit in a
166 	 * 64 rows array of 32 bits: the upper 6 bits of the CAN ID select the
167 	 * row while the lowest 5 bits select the bit in that row.
168 	 *
169 	 * bit	filter
170 	 * 1	passed
171 	 * 0	discarded
172 	 */
173 
174 	/* select the row */
175 	cmd->idx = row;
176 
177 	/* set/unset bits in the row */
178 	cmd->mask = cpu_to_le32(mask);
179 
180 	return pucan_write_cmd(priv);
181 }
182 
183 static int pucan_tx_abort(struct peak_canfd_priv *priv, u16 flags)
184 {
185 	struct pucan_tx_abort *cmd;
186 
187 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_TX_ABORT);
188 
189 	cmd->flags = cpu_to_le16(flags);
190 
191 	return pucan_write_cmd(priv);
192 }
193 
194 static int pucan_clr_err_counters(struct peak_canfd_priv *priv)
195 {
196 	struct pucan_wr_err_cnt *cmd;
197 
198 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_WR_ERR_CNT);
199 
200 	cmd->sel_mask = cpu_to_le16(PUCAN_WRERRCNT_TE | PUCAN_WRERRCNT_RE);
201 	cmd->tx_counter = 0;
202 	cmd->rx_counter = 0;
203 
204 	return pucan_write_cmd(priv);
205 }
206 
207 static int pucan_set_options(struct peak_canfd_priv *priv, u16 opt_mask)
208 {
209 	struct pucan_options *cmd;
210 
211 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_SET_EN_OPTION);
212 
213 	cmd->options = cpu_to_le16(opt_mask);
214 
215 	return pucan_write_cmd(priv);
216 }
217 
218 static int pucan_clr_options(struct peak_canfd_priv *priv, u16 opt_mask)
219 {
220 	struct pucan_options *cmd;
221 
222 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_CLR_DIS_OPTION);
223 
224 	cmd->options = cpu_to_le16(opt_mask);
225 
226 	return pucan_write_cmd(priv);
227 }
228 
229 static int pucan_setup_rx_barrier(struct peak_canfd_priv *priv)
230 {
231 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_RX_BARRIER);
232 
233 	return pucan_write_cmd(priv);
234 }
235 
236 static int pucan_netif_rx(struct sk_buff *skb, __le32 ts_low, __le32 ts_high)
237 {
238 	struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
239 	u64 ts_us;
240 
241 	ts_us = (u64)le32_to_cpu(ts_high) << 32;
242 	ts_us |= le32_to_cpu(ts_low);
243 
244 	/* IP core timestamps are µs. */
245 	hwts->hwtstamp = ns_to_ktime(ts_us * NSEC_PER_USEC);
246 
247 	return netif_rx(skb);
248 }
249 
250 /* handle the reception of one CAN frame */
251 static int pucan_handle_can_rx(struct peak_canfd_priv *priv,
252 			       struct pucan_rx_msg *msg)
253 {
254 	struct net_device_stats *stats = &priv->ndev->stats;
255 	struct canfd_frame *cf;
256 	struct sk_buff *skb;
257 	const u16 rx_msg_flags = le16_to_cpu(msg->flags);
258 	u8 cf_len;
259 
260 	if (rx_msg_flags & PUCAN_MSG_EXT_DATA_LEN)
261 		cf_len = can_fd_dlc2len(pucan_msg_get_dlc(msg));
262 	else
263 		cf_len = can_cc_dlc2len(pucan_msg_get_dlc(msg));
264 
265 	/* if this frame is an echo, */
266 	if (rx_msg_flags & PUCAN_MSG_LOOPED_BACK) {
267 		unsigned long flags;
268 
269 		spin_lock_irqsave(&priv->echo_lock, flags);
270 
271 		/* count bytes of the echo instead of skb */
272 		stats->tx_bytes += can_get_echo_skb(priv->ndev, msg->client, NULL);
273 		stats->tx_packets++;
274 
275 		/* restart tx queue (a slot is free) */
276 		netif_wake_queue(priv->ndev);
277 
278 		spin_unlock_irqrestore(&priv->echo_lock, flags);
279 
280 		/* if this frame is only an echo, stop here. Otherwise,
281 		 * continue to push this application self-received frame into
282 		 * its own rx queue.
283 		 */
284 		if (!(rx_msg_flags & PUCAN_MSG_SELF_RECEIVE))
285 			return 0;
286 	}
287 
288 	/* otherwise, it should be pushed into rx fifo */
289 	if (rx_msg_flags & PUCAN_MSG_EXT_DATA_LEN) {
290 		/* CANFD frame case */
291 		skb = alloc_canfd_skb(priv->ndev, &cf);
292 		if (!skb)
293 			return -ENOMEM;
294 
295 		if (rx_msg_flags & PUCAN_MSG_BITRATE_SWITCH)
296 			cf->flags |= CANFD_BRS;
297 
298 		if (rx_msg_flags & PUCAN_MSG_ERROR_STATE_IND)
299 			cf->flags |= CANFD_ESI;
300 	} else {
301 		/* CAN 2.0 frame case */
302 		skb = alloc_can_skb(priv->ndev, (struct can_frame **)&cf);
303 		if (!skb)
304 			return -ENOMEM;
305 	}
306 
307 	cf->can_id = le32_to_cpu(msg->can_id);
308 	cf->len = cf_len;
309 
310 	if (rx_msg_flags & PUCAN_MSG_EXT_ID)
311 		cf->can_id |= CAN_EFF_FLAG;
312 
313 	if (rx_msg_flags & PUCAN_MSG_RTR) {
314 		cf->can_id |= CAN_RTR_FLAG;
315 	} else {
316 		memcpy(cf->data, msg->d, cf->len);
317 
318 		stats->rx_bytes += cf->len;
319 	}
320 	stats->rx_packets++;
321 
322 	pucan_netif_rx(skb, msg->ts_low, msg->ts_high);
323 
324 	return 0;
325 }
326 
327 /* handle rx/tx error counters notification */
328 static int pucan_handle_error(struct peak_canfd_priv *priv,
329 			      struct pucan_error_msg *msg)
330 {
331 	priv->bec.txerr = msg->tx_err_cnt;
332 	priv->bec.rxerr = msg->rx_err_cnt;
333 
334 	return 0;
335 }
336 
337 /* handle status notification */
338 static int pucan_handle_status(struct peak_canfd_priv *priv,
339 			       struct pucan_status_msg *msg)
340 {
341 	struct net_device *ndev = priv->ndev;
342 	struct net_device_stats *stats = &ndev->stats;
343 	struct can_frame *cf;
344 	struct sk_buff *skb;
345 
346 	/* this STATUS is the CNF of the RX_BARRIER: Tx path can be setup */
347 	if (pucan_status_is_rx_barrier(msg)) {
348 		if (priv->enable_tx_path) {
349 			int err = priv->enable_tx_path(priv);
350 
351 			if (err)
352 				return err;
353 		}
354 
355 		/* wake network queue up (echo_skb array is empty) */
356 		netif_wake_queue(ndev);
357 
358 		return 0;
359 	}
360 
361 	skb = alloc_can_err_skb(ndev, &cf);
362 
363 	/* test state error bits according to their priority */
364 	if (pucan_status_is_busoff(msg)) {
365 		netdev_dbg(ndev, "Bus-off entry status\n");
366 		priv->can.state = CAN_STATE_BUS_OFF;
367 		priv->can.can_stats.bus_off++;
368 		can_bus_off(ndev);
369 		if (skb)
370 			cf->can_id |= CAN_ERR_BUSOFF;
371 
372 	} else if (pucan_status_is_passive(msg)) {
373 		netdev_dbg(ndev, "Error passive status\n");
374 		priv->can.state = CAN_STATE_ERROR_PASSIVE;
375 		priv->can.can_stats.error_passive++;
376 		if (skb) {
377 			cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;
378 			cf->data[1] = (priv->bec.txerr > priv->bec.rxerr) ?
379 					CAN_ERR_CRTL_TX_PASSIVE :
380 					CAN_ERR_CRTL_RX_PASSIVE;
381 			cf->data[6] = priv->bec.txerr;
382 			cf->data[7] = priv->bec.rxerr;
383 		}
384 
385 	} else if (pucan_status_is_warning(msg)) {
386 		netdev_dbg(ndev, "Error warning status\n");
387 		priv->can.state = CAN_STATE_ERROR_WARNING;
388 		priv->can.can_stats.error_warning++;
389 		if (skb) {
390 			cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;
391 			cf->data[1] = (priv->bec.txerr > priv->bec.rxerr) ?
392 					CAN_ERR_CRTL_TX_WARNING :
393 					CAN_ERR_CRTL_RX_WARNING;
394 			cf->data[6] = priv->bec.txerr;
395 			cf->data[7] = priv->bec.rxerr;
396 		}
397 
398 	} else if (priv->can.state != CAN_STATE_ERROR_ACTIVE) {
399 		/* back to ERROR_ACTIVE */
400 		netdev_dbg(ndev, "Error active status\n");
401 		can_change_state(ndev, cf, CAN_STATE_ERROR_ACTIVE,
402 				 CAN_STATE_ERROR_ACTIVE);
403 	} else {
404 		dev_kfree_skb(skb);
405 		return 0;
406 	}
407 
408 	if (!skb) {
409 		stats->rx_dropped++;
410 		return -ENOMEM;
411 	}
412 
413 	pucan_netif_rx(skb, msg->ts_low, msg->ts_high);
414 
415 	return 0;
416 }
417 
418 /* handle uCAN Rx overflow notification */
419 static int pucan_handle_cache_critical(struct peak_canfd_priv *priv)
420 {
421 	struct net_device_stats *stats = &priv->ndev->stats;
422 	struct can_frame *cf;
423 	struct sk_buff *skb;
424 
425 	stats->rx_over_errors++;
426 	stats->rx_errors++;
427 
428 	skb = alloc_can_err_skb(priv->ndev, &cf);
429 	if (!skb) {
430 		stats->rx_dropped++;
431 		return -ENOMEM;
432 	}
433 
434 	cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;
435 	cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
436 
437 	cf->data[6] = priv->bec.txerr;
438 	cf->data[7] = priv->bec.rxerr;
439 
440 	netif_rx(skb);
441 
442 	return 0;
443 }
444 
445 /* handle a single uCAN message */
446 int peak_canfd_handle_msg(struct peak_canfd_priv *priv,
447 			  struct pucan_rx_msg *msg)
448 {
449 	u16 msg_type = le16_to_cpu(msg->type);
450 	int msg_size = le16_to_cpu(msg->size);
451 	int err;
452 
453 	if (!msg_size || !msg_type) {
454 		/* null packet found: end of list */
455 		goto exit;
456 	}
457 
458 	switch (msg_type) {
459 	case PUCAN_MSG_CAN_RX:
460 		err = pucan_handle_can_rx(priv, (struct pucan_rx_msg *)msg);
461 		break;
462 	case PUCAN_MSG_ERROR:
463 		err = pucan_handle_error(priv, (struct pucan_error_msg *)msg);
464 		break;
465 	case PUCAN_MSG_STATUS:
466 		err = pucan_handle_status(priv, (struct pucan_status_msg *)msg);
467 		break;
468 	case PUCAN_MSG_CACHE_CRITICAL:
469 		err = pucan_handle_cache_critical(priv);
470 		break;
471 	default:
472 		err = 0;
473 	}
474 
475 	if (err < 0)
476 		return err;
477 
478 exit:
479 	return msg_size;
480 }
481 
482 /* handle a list of rx_count messages from rx_msg memory address */
483 int peak_canfd_handle_msgs_list(struct peak_canfd_priv *priv,
484 				struct pucan_rx_msg *msg_list, int msg_count)
485 {
486 	void *msg_ptr = msg_list;
487 	int i, msg_size = 0;
488 
489 	for (i = 0; i < msg_count; i++) {
490 		msg_size = peak_canfd_handle_msg(priv, msg_ptr);
491 
492 		/* a null packet can be found at the end of a list */
493 		if (msg_size <= 0)
494 			break;
495 
496 		msg_ptr += ALIGN(msg_size, 4);
497 	}
498 
499 	if (msg_size < 0)
500 		return msg_size;
501 
502 	return i;
503 }
504 
505 static int peak_canfd_start(struct peak_canfd_priv *priv)
506 {
507 	int err;
508 
509 	err = pucan_clr_err_counters(priv);
510 	if (err)
511 		goto err_exit;
512 
513 	priv->echo_idx = 0;
514 
515 	priv->bec.txerr = 0;
516 	priv->bec.rxerr = 0;
517 
518 	if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
519 		err = pucan_set_listen_only_mode(priv);
520 	else
521 		err = pucan_set_normal_mode(priv);
522 
523 err_exit:
524 	return err;
525 }
526 
527 static void peak_canfd_stop(struct peak_canfd_priv *priv)
528 {
529 	int err;
530 
531 	/* go back to RESET mode */
532 	err = pucan_set_reset_mode(priv);
533 	if (err) {
534 		netdev_err(priv->ndev, "channel %u reset failed\n",
535 			   priv->index);
536 	} else {
537 		/* abort last Tx (MUST be done in RESET mode only!) */
538 		pucan_tx_abort(priv, PUCAN_TX_ABORT_FLUSH);
539 	}
540 }
541 
542 static int peak_canfd_set_mode(struct net_device *ndev, enum can_mode mode)
543 {
544 	struct peak_canfd_priv *priv = netdev_priv(ndev);
545 
546 	switch (mode) {
547 	case CAN_MODE_START:
548 		peak_canfd_start(priv);
549 		netif_wake_queue(ndev);
550 		break;
551 	default:
552 		return -EOPNOTSUPP;
553 	}
554 
555 	return 0;
556 }
557 
558 static int peak_canfd_get_berr_counter(const struct net_device *ndev,
559 				       struct can_berr_counter *bec)
560 {
561 	struct peak_canfd_priv *priv = netdev_priv(ndev);
562 
563 	*bec = priv->bec;
564 	return 0;
565 }
566 
567 static int peak_canfd_open(struct net_device *ndev)
568 {
569 	struct peak_canfd_priv *priv = netdev_priv(ndev);
570 	int i, err = 0;
571 
572 	err = open_candev(ndev);
573 	if (err) {
574 		netdev_err(ndev, "open_candev() failed, error %d\n", err);
575 		goto err_exit;
576 	}
577 
578 	err = pucan_set_reset_mode(priv);
579 	if (err)
580 		goto err_close;
581 
582 	if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
583 		if (priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)
584 			err = pucan_clr_options(priv, PUCAN_OPTION_CANDFDISO);
585 		else
586 			err = pucan_set_options(priv, PUCAN_OPTION_CANDFDISO);
587 
588 		if (err)
589 			goto err_close;
590 	}
591 
592 	/* set option: get rx/tx error counters */
593 	err = pucan_set_options(priv, PUCAN_OPTION_ERROR);
594 	if (err)
595 		goto err_close;
596 
597 	/* accept all standard CAN ID */
598 	for (i = 0; i <= PUCAN_FLTSTD_ROW_IDX_MAX; i++)
599 		pucan_set_std_filter(priv, i, 0xffffffff);
600 
601 	err = peak_canfd_start(priv);
602 	if (err)
603 		goto err_close;
604 
605 	/* receiving the RB status says when Tx path is ready */
606 	err = pucan_setup_rx_barrier(priv);
607 	if (!err)
608 		goto err_exit;
609 
610 err_close:
611 	close_candev(ndev);
612 err_exit:
613 	return err;
614 }
615 
616 static int peak_canfd_set_bittiming(struct net_device *ndev)
617 {
618 	struct peak_canfd_priv *priv = netdev_priv(ndev);
619 
620 	return pucan_set_timing_slow(priv, &priv->can.bittiming);
621 }
622 
623 static int peak_canfd_set_data_bittiming(struct net_device *ndev)
624 {
625 	struct peak_canfd_priv *priv = netdev_priv(ndev);
626 
627 	return pucan_set_timing_fast(priv, &priv->can.data_bittiming);
628 }
629 
630 static int peak_canfd_close(struct net_device *ndev)
631 {
632 	struct peak_canfd_priv *priv = netdev_priv(ndev);
633 
634 	netif_stop_queue(ndev);
635 	peak_canfd_stop(priv);
636 	close_candev(ndev);
637 
638 	return 0;
639 }
640 
641 static netdev_tx_t peak_canfd_start_xmit(struct sk_buff *skb,
642 					 struct net_device *ndev)
643 {
644 	struct peak_canfd_priv *priv = netdev_priv(ndev);
645 	struct net_device_stats *stats = &ndev->stats;
646 	struct canfd_frame *cf = (struct canfd_frame *)skb->data;
647 	struct pucan_tx_msg *msg;
648 	u16 msg_size, msg_flags;
649 	unsigned long flags;
650 	bool should_stop_tx_queue;
651 	int room_left;
652 	u8 len;
653 
654 	if (can_dev_dropped_skb(ndev, skb))
655 		return NETDEV_TX_OK;
656 
657 	msg_size = ALIGN(sizeof(*msg) + cf->len, 4);
658 	msg = priv->alloc_tx_msg(priv, msg_size, &room_left);
659 
660 	/* should never happen except under bus-off condition and (auto-)restart
661 	 * mechanism
662 	 */
663 	if (!msg) {
664 		stats->tx_dropped++;
665 		netif_stop_queue(ndev);
666 		return NETDEV_TX_BUSY;
667 	}
668 
669 	msg->size = cpu_to_le16(msg_size);
670 	msg->type = cpu_to_le16(PUCAN_MSG_CAN_TX);
671 	msg_flags = 0;
672 
673 	if (cf->can_id & CAN_EFF_FLAG) {
674 		msg_flags |= PUCAN_MSG_EXT_ID;
675 		msg->can_id = cpu_to_le32(cf->can_id & CAN_EFF_MASK);
676 	} else {
677 		msg->can_id = cpu_to_le32(cf->can_id & CAN_SFF_MASK);
678 	}
679 
680 	if (can_is_canfd_skb(skb)) {
681 		/* CAN FD frame format */
682 		len = can_fd_len2dlc(cf->len);
683 
684 		msg_flags |= PUCAN_MSG_EXT_DATA_LEN;
685 
686 		if (cf->flags & CANFD_BRS)
687 			msg_flags |= PUCAN_MSG_BITRATE_SWITCH;
688 
689 		if (cf->flags & CANFD_ESI)
690 			msg_flags |= PUCAN_MSG_ERROR_STATE_IND;
691 	} else {
692 		/* CAN 2.0 frame format */
693 		len = cf->len;
694 
695 		if (cf->can_id & CAN_RTR_FLAG)
696 			msg_flags |= PUCAN_MSG_RTR;
697 	}
698 
699 	/* always ask loopback for echo management */
700 	msg_flags |= PUCAN_MSG_LOOPED_BACK;
701 
702 	/* set driver specific bit to differentiate with application loopback */
703 	if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
704 		msg_flags |= PUCAN_MSG_SELF_RECEIVE;
705 
706 	msg->flags = cpu_to_le16(msg_flags);
707 	msg->channel_dlc = PUCAN_MSG_CHANNEL_DLC(priv->index, len);
708 	memcpy(msg->d, cf->data, cf->len);
709 
710 	/* struct msg client field is used as an index in the echo skbs ring */
711 	msg->client = priv->echo_idx;
712 
713 	spin_lock_irqsave(&priv->echo_lock, flags);
714 
715 	/* prepare and save echo skb in internal slot */
716 	can_put_echo_skb(skb, ndev, priv->echo_idx, 0);
717 
718 	/* move echo index to the next slot */
719 	priv->echo_idx = (priv->echo_idx + 1) % priv->can.echo_skb_max;
720 
721 	/* if next slot is not free, stop network queue (no slot free in echo
722 	 * skb ring means that the controller did not write these frames on
723 	 * the bus: no need to continue).
724 	 */
725 	should_stop_tx_queue = !!(priv->can.echo_skb[priv->echo_idx]);
726 
727 	/* stop network tx queue if not enough room to save one more msg too */
728 	if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
729 		should_stop_tx_queue |= (room_left <
730 					(sizeof(*msg) + CANFD_MAX_DLEN));
731 	else
732 		should_stop_tx_queue |= (room_left <
733 					(sizeof(*msg) + CAN_MAX_DLEN));
734 
735 	if (should_stop_tx_queue)
736 		netif_stop_queue(ndev);
737 
738 	spin_unlock_irqrestore(&priv->echo_lock, flags);
739 
740 	/* write the skb on the interface */
741 	priv->write_tx_msg(priv, msg);
742 
743 	return NETDEV_TX_OK;
744 }
745 
746 static int peak_eth_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
747 {
748 	struct hwtstamp_config hwts_cfg = { 0 };
749 
750 	switch (cmd) {
751 	case SIOCSHWTSTAMP: /* set */
752 		if (copy_from_user(&hwts_cfg, ifr->ifr_data, sizeof(hwts_cfg)))
753 			return -EFAULT;
754 		if (hwts_cfg.tx_type == HWTSTAMP_TX_OFF &&
755 		    hwts_cfg.rx_filter == HWTSTAMP_FILTER_ALL)
756 			return 0;
757 		return -ERANGE;
758 
759 	case SIOCGHWTSTAMP: /* get */
760 		hwts_cfg.tx_type = HWTSTAMP_TX_OFF;
761 		hwts_cfg.rx_filter = HWTSTAMP_FILTER_ALL;
762 		if (copy_to_user(ifr->ifr_data, &hwts_cfg, sizeof(hwts_cfg)))
763 			return -EFAULT;
764 		return 0;
765 
766 	default:
767 		return -EOPNOTSUPP;
768 	}
769 }
770 
771 static const struct net_device_ops peak_canfd_netdev_ops = {
772 	.ndo_open = peak_canfd_open,
773 	.ndo_stop = peak_canfd_close,
774 	.ndo_eth_ioctl = peak_eth_ioctl,
775 	.ndo_start_xmit = peak_canfd_start_xmit,
776 	.ndo_change_mtu = can_change_mtu,
777 };
778 
779 static int peak_get_ts_info(struct net_device *dev,
780 			    struct ethtool_ts_info *info)
781 {
782 	info->so_timestamping =
783 		SOF_TIMESTAMPING_TX_SOFTWARE |
784 		SOF_TIMESTAMPING_RX_SOFTWARE |
785 		SOF_TIMESTAMPING_SOFTWARE |
786 		SOF_TIMESTAMPING_RX_HARDWARE |
787 		SOF_TIMESTAMPING_RAW_HARDWARE;
788 	info->phc_index = -1;
789 	info->tx_types = BIT(HWTSTAMP_TX_OFF);
790 	info->rx_filters = BIT(HWTSTAMP_FILTER_ALL);
791 
792 	return 0;
793 }
794 
795 static const struct ethtool_ops peak_canfd_ethtool_ops = {
796 	.get_ts_info = peak_get_ts_info,
797 };
798 
799 struct net_device *alloc_peak_canfd_dev(int sizeof_priv, int index,
800 					int echo_skb_max)
801 {
802 	struct net_device *ndev;
803 	struct peak_canfd_priv *priv;
804 
805 	/* we DO support local echo */
806 	if (echo_skb_max < 0)
807 		echo_skb_max = PCANFD_ECHO_SKB_MAX;
808 
809 	/* allocate the candev object */
810 	ndev = alloc_candev(sizeof_priv, echo_skb_max);
811 	if (!ndev)
812 		return NULL;
813 
814 	priv = netdev_priv(ndev);
815 
816 	/* complete now socket-can initialization side */
817 	priv->can.state = CAN_STATE_STOPPED;
818 	priv->can.bittiming_const = &peak_canfd_nominal_const;
819 	priv->can.data_bittiming_const = &peak_canfd_data_const;
820 
821 	priv->can.do_set_mode = peak_canfd_set_mode;
822 	priv->can.do_get_berr_counter = peak_canfd_get_berr_counter;
823 	priv->can.do_set_bittiming = peak_canfd_set_bittiming;
824 	priv->can.do_set_data_bittiming = peak_canfd_set_data_bittiming;
825 	priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
826 				       CAN_CTRLMODE_LISTENONLY |
827 				       CAN_CTRLMODE_3_SAMPLES |
828 				       CAN_CTRLMODE_FD |
829 				       CAN_CTRLMODE_FD_NON_ISO |
830 				       CAN_CTRLMODE_BERR_REPORTING;
831 
832 	priv->ndev = ndev;
833 	priv->index = index;
834 	priv->cmd_len = 0;
835 	spin_lock_init(&priv->echo_lock);
836 
837 	ndev->flags |= IFF_ECHO;
838 	ndev->netdev_ops = &peak_canfd_netdev_ops;
839 	ndev->ethtool_ops = &peak_canfd_ethtool_ops;
840 	ndev->dev_id = index;
841 
842 	return ndev;
843 }
844