can/peak_canfd/peak_canfd.c

42 static struct peak_canfd_priv *pucan_init_cmd(struct peak_canfd_priv *priv)
44 	priv->cmd_len = 0;
45 	return priv;
48 static void *pucan_add_cmd(struct peak_canfd_priv *priv, int cmd_op)
52 	if (priv->cmd_len + sizeof(*cmd) > priv->cmd_maxlen)
55 	cmd = priv->cmd_buffer + priv->cmd_len;
60 	cmd->opcode_channel = pucan_cmd_opcode_channel(priv->index, cmd_op);
61 	priv->cmd_len += sizeof(*cmd);
66 static int pucan_write_cmd(struct peak_canfd_priv *priv)
70 	if (priv->pre_cmd) {
71 		err = priv->pre_cmd(priv);
76 	err = priv->write_cmd(priv);
80 	if (priv->post_cmd)
81 		err = priv->post_cmd(priv);
87 static int pucan_set_reset_mode(struct peak_canfd_priv *priv)
89 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_RESET_MODE);
90 	return pucan_write_cmd(priv);
93 static int pucan_set_normal_mode(struct peak_canfd_priv *priv)
97 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_NORMAL_MODE);
98 	err = pucan_write_cmd(priv);
100 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
105 static int pucan_set_listen_only_mode(struct peak_canfd_priv *priv)
109 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_LISTEN_ONLY_MODE);
110 	err = pucan_write_cmd(priv);
112 		priv->can.state = CAN_STATE_ERROR_ACTIVE;
117 static int pucan_set_timing_slow(struct peak_canfd_priv *priv,
122 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_TIMING_SLOW);
125 				       priv->can.ctrlmode &
133 	netdev_dbg(priv->ndev,
137 	return pucan_write_cmd(priv);
140 static int pucan_set_timing_fast(struct peak_canfd_priv *priv,
145 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_TIMING_FAST);
152 	netdev_dbg(priv->ndev,
156 	return pucan_write_cmd(priv);
159 static int pucan_set_std_filter(struct peak_canfd_priv *priv, u8 row, u32 mask)
163 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_SET_STD_FILTER);
180 	return pucan_write_cmd(priv);
183 static int pucan_tx_abort(struct peak_canfd_priv *priv, u16 flags)
187 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_TX_ABORT);
191 	return pucan_write_cmd(priv);
194 static int pucan_clr_err_counters(struct peak_canfd_priv *priv)
198 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_WR_ERR_CNT);
204 	return pucan_write_cmd(priv);
207 static int pucan_set_options(struct peak_canfd_priv *priv, u16 opt_mask)
211 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_SET_EN_OPTION);
215 	return pucan_write_cmd(priv);
218 static int pucan_clr_options(struct peak_canfd_priv *priv, u16 opt_mask)
222 	cmd = pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_CLR_DIS_OPTION);
226 	return pucan_write_cmd(priv);
229 static int pucan_setup_rx_barrier(struct peak_canfd_priv *priv)
231 	pucan_add_cmd(pucan_init_cmd(priv), PUCAN_CMD_RX_BARRIER);
233 	return pucan_write_cmd(priv);
251 static int pucan_handle_can_rx(struct peak_canfd_priv *priv,
254 	struct net_device_stats *stats = &priv->ndev->stats;
269 		spin_lock_irqsave(&priv->echo_lock, flags);
272 		stats->tx_bytes += can_get_echo_skb(priv->ndev, msg->client, NULL);
276 		netif_wake_queue(priv->ndev);
278 		spin_unlock_irqrestore(&priv->echo_lock, flags);
291 		skb = alloc_canfd_skb(priv->ndev, &cf);
302 		skb = alloc_can_skb(priv->ndev, (struct can_frame **)&cf);
328 static int pucan_handle_error(struct peak_canfd_priv *priv,
331 	priv->bec.txerr = msg->tx_err_cnt;
332 	priv->bec.rxerr = msg->rx_err_cnt;
338 static int pucan_handle_status(struct peak_canfd_priv *priv,
341 	struct net_device *ndev = priv->ndev;
348 		if (priv->enable_tx_path) {
349 			int err = priv->enable_tx_path(priv);
366 		priv->can.state = CAN_STATE_BUS_OFF;
367 		priv->can.can_stats.bus_off++;
374 		priv->can.state = CAN_STATE_ERROR_PASSIVE;
375 		priv->can.can_stats.error_passive++;
378 			cf->data[1] = (priv->bec.txerr > priv->bec.rxerr) ?
381 			cf->data[6] = priv->bec.txerr;
382 			cf->data[7] = priv->bec.rxerr;
387 		priv->can.state = CAN_STATE_ERROR_WARNING;
388 		priv->can.can_stats.error_warning++;
391 			cf->data[1] = (priv->bec.txerr > priv->bec.rxerr) ?
394 			cf->data[6] = priv->bec.txerr;
395 			cf->data[7] = priv->bec.rxerr;
398 	} else if (priv->can.state != CAN_STATE_ERROR_ACTIVE) {
419 static int pucan_handle_cache_critical(struct peak_canfd_priv *priv)
421 	struct net_device_stats *stats = &priv->ndev->stats;
428 	skb = alloc_can_err_skb(priv->ndev, &cf);
437 	cf->data[6] = priv->bec.txerr;
438 	cf->data[7] = priv->bec.rxerr;
446 int peak_canfd_handle_msg(struct peak_canfd_priv *priv,
460 		err = pucan_handle_can_rx(priv, (struct pucan_rx_msg *)msg);
463 		err = pucan_handle_error(priv, (struct pucan_error_msg *)msg);
466 		err = pucan_handle_status(priv, (struct pucan_status_msg *)msg);
469 		err = pucan_handle_cache_critical(priv);
483 int peak_canfd_handle_msgs_list(struct peak_canfd_priv *priv,
490 		msg_size = peak_canfd_handle_msg(priv, msg_ptr);
505 static int peak_canfd_start(struct peak_canfd_priv *priv)
509 	err = pucan_clr_err_counters(priv);
513 	priv->echo_idx = 0;
515 	priv->bec.txerr = 0;
516 	priv->bec.rxerr = 0;
518 	if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
519 		err = pucan_set_listen_only_mode(priv);
521 		err = pucan_set_normal_mode(priv);
527 static void peak_canfd_stop(struct peak_canfd_priv *priv)
532 	err = pucan_set_reset_mode(priv);
534 		netdev_err(priv->ndev, "channel %u reset failed\n",
535 			   priv->index);
538 		pucan_tx_abort(priv, PUCAN_TX_ABORT_FLUSH);
544 	struct peak_canfd_priv *priv = netdev_priv(ndev);
548 		peak_canfd_start(priv);
561 	struct peak_canfd_priv *priv = netdev_priv(ndev);
563 	*bec = priv->bec;
569 	struct peak_canfd_priv *priv = netdev_priv(ndev);
578 	err = pucan_set_reset_mode(priv);
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);
586 			err = pucan_set_options(priv, PUCAN_OPTION_CANDFDISO);
593 	err = pucan_set_options(priv, PUCAN_OPTION_ERROR);
599 		pucan_set_std_filter(priv, i, 0xffffffff);
601 	err = peak_canfd_start(priv);
606 	err = pucan_setup_rx_barrier(priv);
618 	struct peak_canfd_priv *priv = netdev_priv(ndev);
620 	return pucan_set_timing_slow(priv, &priv->can.bittiming);
625 	struct peak_canfd_priv *priv = netdev_priv(ndev);
627 	return pucan_set_timing_fast(priv, &priv->can.fd.data_bittiming);
632 	struct peak_canfd_priv *priv = netdev_priv(ndev);
635 	peak_canfd_stop(priv);
644 	struct peak_canfd_priv *priv = netdev_priv(ndev);
658 	msg = priv->alloc_tx_msg(priv, msg_size, &room_left);
703 	if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
707 	msg->channel_dlc = PUCAN_MSG_CHANNEL_DLC(priv->index, len);
711 	msg->client = priv->echo_idx;
713 	spin_lock_irqsave(&priv->echo_lock, flags);
716 	can_put_echo_skb(skb, ndev, priv->echo_idx, 0);
719 	priv->echo_idx = (priv->echo_idx + 1) % priv->can.echo_skb_max;
725 	should_stop_tx_queue = !!(priv->can.echo_skb[priv->echo_idx]);
728 	if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
738 	spin_unlock_irqrestore(&priv->echo_lock, flags);
741 	priv->write_tx_msg(priv, msg);
800 	struct peak_canfd_priv *priv;
811 	priv = netdev_priv(ndev);
814 	priv->can.state = CAN_STATE_STOPPED;
815 	priv->can.bittiming_const = &peak_canfd_nominal_const;
816 	priv->can.fd.data_bittiming_const = &peak_canfd_data_const;
818 	priv->can.do_set_mode = peak_canfd_set_mode;
819 	priv->can.do_get_berr_counter = peak_canfd_get_berr_counter;
820 	priv->can.do_set_bittiming = peak_canfd_set_bittiming;
821 	priv->can.fd.do_set_data_bittiming = peak_canfd_set_data_bittiming;
822 	priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
829 	priv->ndev = ndev;
830 	priv->index = index;
831 	priv->cmd_len = 0;
832 	spin_lock_init(&priv->echo_lock);