1 // SPDX-License-Identifier: GPL-2.0
3 // Copyright (c) 2023, 2024 Pengutronix,
8 // Rockchip CANFD driver
10 // Copyright (c) 2020 Rockchip Electronics Co. Ltd.
13 #include <linux/delay.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
20 #include <linux/of_device.h>
21 #include <linux/platform_device.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/string.h>
25 #include "rockchip_canfd.h"
27 static const struct rkcanfd_devtype_data rkcanfd_devtype_data_rk3568v2 = {
28 .model = RKCANFD_MODEL_RK3568V2,
29 .quirks = RKCANFD_QUIRK_RK3568_ERRATUM_1 | RKCANFD_QUIRK_RK3568_ERRATUM_2 |
30 RKCANFD_QUIRK_RK3568_ERRATUM_3 | RKCANFD_QUIRK_RK3568_ERRATUM_4 |
31 RKCANFD_QUIRK_RK3568_ERRATUM_5 | RKCANFD_QUIRK_RK3568_ERRATUM_6 |
32 RKCANFD_QUIRK_RK3568_ERRATUM_7 | RKCANFD_QUIRK_RK3568_ERRATUM_8 |
33 RKCANFD_QUIRK_RK3568_ERRATUM_9 | RKCANFD_QUIRK_RK3568_ERRATUM_10 |
34 RKCANFD_QUIRK_RK3568_ERRATUM_11 | RKCANFD_QUIRK_RK3568_ERRATUM_12 |
35 RKCANFD_QUIRK_CANFD_BROKEN,
38 /* The rk3568 CAN-FD errata sheet as of Tue 07 Nov 2023 11:25:31 +08:00
39 * states that only the rk3568v2 is affected by erratum 5, but tests
40 * with the rk3568v2 and rk3568v3 show that the RX_FIFO_CNT is
41 * sometimes too high. In contrast to the errata sheet mark rk3568v3
42 * as effected by erratum 5, too.
44 static const struct rkcanfd_devtype_data rkcanfd_devtype_data_rk3568v3 = {
45 .model = RKCANFD_MODEL_RK3568V3,
46 .quirks = RKCANFD_QUIRK_RK3568_ERRATUM_1 | RKCANFD_QUIRK_RK3568_ERRATUM_2 |
47 RKCANFD_QUIRK_RK3568_ERRATUM_5 | RKCANFD_QUIRK_RK3568_ERRATUM_7 |
48 RKCANFD_QUIRK_RK3568_ERRATUM_8 | RKCANFD_QUIRK_RK3568_ERRATUM_10 |
49 RKCANFD_QUIRK_RK3568_ERRATUM_11 | RKCANFD_QUIRK_RK3568_ERRATUM_12 |
50 RKCANFD_QUIRK_CANFD_BROKEN,
53 static const char *__rkcanfd_get_model_str(enum rkcanfd_model model)
56 case RKCANFD_MODEL_RK3568V2:
58 case RKCANFD_MODEL_RK3568V3:
65 static inline const char *
66 rkcanfd_get_model_str(const struct rkcanfd_priv *priv)
68 return __rkcanfd_get_model_str(priv->devtype_data.model);
73 * The formula to calculate the CAN System Clock is:
75 * Tsclk = 2 x Tclk x (brp + 1)
77 * Double the data sheet's brp_min, brp_max and brp_inc values (both
78 * for the arbitration and data bit timing) to take the "2 x" into
81 static const struct can_bittiming_const rkcanfd_bittiming_const = {
88 .brp_min = 2, /* value from data sheet x2 */
89 .brp_max = 512, /* value from data sheet x2 */
90 .brp_inc = 2, /* value from data sheet x2 */
93 static const struct can_bittiming_const rkcanfd_data_bittiming_const = {
100 .brp_min = 2, /* value from data sheet x2 */
101 .brp_max = 512, /* value from data sheet x2 */
102 .brp_inc = 2, /* value from data sheet x2 */
105 static void rkcanfd_chip_set_reset_mode(const struct rkcanfd_priv *priv)
107 reset_control_assert(priv->reset);
109 reset_control_deassert(priv->reset);
111 rkcanfd_write(priv, RKCANFD_REG_MODE, 0x0);
114 static void rkcanfd_chip_set_work_mode(const struct rkcanfd_priv *priv)
116 rkcanfd_write(priv, RKCANFD_REG_MODE, priv->reg_mode_default);
119 static int rkcanfd_set_bittiming(struct rkcanfd_priv *priv)
121 const struct can_bittiming *dbt = &priv->can.data_bittiming;
122 const struct can_bittiming *bt = &priv->can.bittiming;
123 u32 reg_nbt, reg_dbt, reg_tdc;
126 reg_nbt = FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_SJW,
128 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_BRP,
130 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_TSEG2,
131 bt->phase_seg2 - 1) |
132 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_TSEG1,
133 bt->prop_seg + bt->phase_seg1 - 1);
135 rkcanfd_write(priv, RKCANFD_REG_FD_NOMINAL_BITTIMING, reg_nbt);
137 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))
140 reg_dbt = FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_SJW,
142 FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_BRP,
143 (dbt->brp / 2) - 1) |
144 FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_TSEG2,
145 dbt->phase_seg2 - 1) |
146 FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_TSEG1,
147 dbt->prop_seg + dbt->phase_seg1 - 1);
149 rkcanfd_write(priv, RKCANFD_REG_FD_DATA_BITTIMING, reg_dbt);
151 tdco = (priv->can.clock.freq / dbt->bitrate) * 2 / 3;
152 tdco = min(tdco, FIELD_MAX(RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_OFFSET));
154 reg_tdc = FIELD_PREP(RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_OFFSET, tdco) |
155 RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_ENABLE;
156 rkcanfd_write(priv, RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION,
162 static void rkcanfd_get_berr_counter_corrected(struct rkcanfd_priv *priv,
163 struct can_berr_counter *bec)
165 struct can_berr_counter bec_raw;
168 bec->rxerr = rkcanfd_read(priv, RKCANFD_REG_RXERRORCNT);
169 bec->txerr = rkcanfd_read(priv, RKCANFD_REG_TXERRORCNT);
172 /* Tests show that sometimes both CAN bus error counters read
173 * 0x0, even if the controller is in warning mode
174 * (RKCANFD_REG_STATE_ERROR_WARNING_STATE in RKCANFD_REG_STATE
177 * In case both error counters read 0x0, use the struct
178 * priv->bec, otherwise save the read value to priv->bec.
180 * rkcanfd_handle_rx_int_one() handles the decrementing of
181 * priv->bec.rxerr for successfully RX'ed CAN frames.
183 * Luckily the controller doesn't decrement the RX CAN bus
184 * error counter in hardware for self received TX'ed CAN
185 * frames (RKCANFD_REG_MODE_RXSTX_MODE), so RXSTX doesn't
186 * interfere with proper RX CAN bus error counters.
188 * rkcanfd_handle_tx_done_one() handles the decrementing of
189 * priv->bec.txerr for successfully TX'ed CAN frames.
191 if (!bec->rxerr && !bec->txerr)
196 reg_state = rkcanfd_read(priv, RKCANFD_REG_STATE);
197 netdev_vdbg(priv->ndev,
198 "%s: Raw/Cor: txerr=%3u/%3u rxerr=%3u/%3u Bus Off=%u Warning=%u\n",
200 bec_raw.txerr, bec->txerr, bec_raw.rxerr, bec->rxerr,
201 !!(reg_state & RKCANFD_REG_STATE_BUS_OFF_STATE),
202 !!(reg_state & RKCANFD_REG_STATE_ERROR_WARNING_STATE));
205 static int rkcanfd_get_berr_counter(const struct net_device *ndev,
206 struct can_berr_counter *bec)
208 struct rkcanfd_priv *priv = netdev_priv(ndev);
211 err = pm_runtime_resume_and_get(ndev->dev.parent);
215 rkcanfd_get_berr_counter_corrected(priv, bec);
217 pm_runtime_put(ndev->dev.parent);
222 static void rkcanfd_chip_interrupts_enable(const struct rkcanfd_priv *priv)
224 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, priv->reg_int_mask_default);
226 netdev_dbg(priv->ndev, "%s: reg_int_mask=0x%08x\n", __func__,
227 rkcanfd_read(priv, RKCANFD_REG_INT_MASK));
230 static void rkcanfd_chip_interrupts_disable(const struct rkcanfd_priv *priv)
232 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, RKCANFD_REG_INT_ALL);
235 static void rkcanfd_chip_fifo_setup(struct rkcanfd_priv *priv)
240 reg = rkcanfd_read(priv, RKCANFD_REG_RX_FIFO_CTRL);
241 reg |= RKCANFD_REG_RX_FIFO_CTRL_RX_FIFO_ENABLE;
242 rkcanfd_write(priv, RKCANFD_REG_RX_FIFO_CTRL, reg);
245 reg = rkcanfd_read(priv, RKCANFD_REG_RX_FIFO_CTRL);
246 reg |= RKCANFD_REG_RX_FIFO_CTRL_RX_FIFO_ENABLE;
247 rkcanfd_write(priv, RKCANFD_REG_RX_FIFO_CTRL, reg);
249 WRITE_ONCE(priv->tx_head, 0);
250 WRITE_ONCE(priv->tx_tail, 0);
251 netdev_reset_queue(priv->ndev);
254 static void rkcanfd_chip_start(struct rkcanfd_priv *priv)
258 rkcanfd_chip_set_reset_mode(priv);
260 /* Receiving Filter: accept all */
261 rkcanfd_write(priv, RKCANFD_REG_IDCODE, 0x0);
262 rkcanfd_write(priv, RKCANFD_REG_IDMASK, RKCANFD_REG_IDCODE_EXTENDED_FRAME_ID);
265 * - CAN_FD: enable CAN-FD
266 * - AUTO_RETX_MODE: auto retransmission on TX error
267 * - COVER_MODE: RX-FIFO overwrite mode, do not send OVERLOAD frames
268 * - RXSTX_MODE: Receive Self Transmit data mode
269 * - WORK_MODE: transition from reset to working mode
271 reg = rkcanfd_read(priv, RKCANFD_REG_MODE);
272 priv->reg_mode_default = reg |
273 RKCANFD_REG_MODE_CAN_FD_MODE_ENABLE |
274 RKCANFD_REG_MODE_AUTO_RETX_MODE |
275 RKCANFD_REG_MODE_COVER_MODE |
276 RKCANFD_REG_MODE_RXSTX_MODE |
277 RKCANFD_REG_MODE_WORK_MODE;
279 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
280 priv->reg_mode_default |= RKCANFD_REG_MODE_LBACK_MODE |
281 RKCANFD_REG_MODE_SILENT_MODE |
282 RKCANFD_REG_MODE_SELF_TEST;
284 /* mask, i.e. ignore:
285 * - TIMESTAMP_COUNTER_OVERFLOW_INT - timestamp counter overflow interrupt
286 * - TX_ARBIT_FAIL_INT - TX arbitration fail interrupt
287 * - OVERLOAD_INT - CAN bus overload interrupt
288 * - TX_FINISH_INT - Transmit finish interrupt
290 priv->reg_int_mask_default =
291 RKCANFD_REG_INT_TIMESTAMP_COUNTER_OVERFLOW_INT |
292 RKCANFD_REG_INT_TX_ARBIT_FAIL_INT |
293 RKCANFD_REG_INT_OVERLOAD_INT |
294 RKCANFD_REG_INT_TX_FINISH_INT;
296 /* Do not mask the bus error interrupt if the bus error
297 * reporting is requested.
299 if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING))
300 priv->reg_int_mask_default |= RKCANFD_REG_INT_ERROR_INT;
302 memset(&priv->bec, 0x0, sizeof(priv->bec));
304 rkcanfd_chip_fifo_setup(priv);
305 rkcanfd_timestamp_init(priv);
306 rkcanfd_timestamp_start(priv);
308 rkcanfd_set_bittiming(priv);
310 rkcanfd_chip_interrupts_disable(priv);
311 rkcanfd_chip_set_work_mode(priv);
313 priv->can.state = CAN_STATE_ERROR_ACTIVE;
315 netdev_dbg(priv->ndev, "%s: reg_mode=0x%08x\n", __func__,
316 rkcanfd_read(priv, RKCANFD_REG_MODE));
319 static void __rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state)
321 priv->can.state = state;
323 rkcanfd_chip_set_reset_mode(priv);
324 rkcanfd_chip_interrupts_disable(priv);
327 static void rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state)
329 priv->can.state = state;
331 rkcanfd_timestamp_stop(priv);
332 __rkcanfd_chip_stop(priv, state);
335 static void rkcanfd_chip_stop_sync(struct rkcanfd_priv *priv, const enum can_state state)
337 priv->can.state = state;
339 rkcanfd_timestamp_stop_sync(priv);
340 __rkcanfd_chip_stop(priv, state);
343 static int rkcanfd_set_mode(struct net_device *ndev,
346 struct rkcanfd_priv *priv = netdev_priv(ndev);
350 rkcanfd_chip_start(priv);
351 rkcanfd_chip_interrupts_enable(priv);
352 netif_wake_queue(ndev);
362 static struct sk_buff *
363 rkcanfd_alloc_can_err_skb(struct rkcanfd_priv *priv,
364 struct can_frame **cf, u32 *timestamp)
368 *timestamp = rkcanfd_get_timestamp(priv);
370 skb = alloc_can_err_skb(priv->ndev, cf);
372 rkcanfd_skb_set_timestamp(priv, skb, *timestamp);
377 static const char *rkcanfd_get_error_type_str(unsigned int type)
380 case RKCANFD_REG_ERROR_CODE_TYPE_BIT:
382 case RKCANFD_REG_ERROR_CODE_TYPE_STUFF:
384 case RKCANFD_REG_ERROR_CODE_TYPE_FORM:
386 case RKCANFD_REG_ERROR_CODE_TYPE_ACK:
388 case RKCANFD_REG_ERROR_CODE_TYPE_CRC:
395 #define RKCAN_ERROR_CODE(reg_ec, code) \
396 ((reg_ec) & RKCANFD_REG_ERROR_CODE_##code ? __stringify(code) " " : "")
399 rkcanfd_handle_error_int_reg_ec(struct rkcanfd_priv *priv, struct can_frame *cf,
402 struct net_device_stats *stats = &priv->ndev->stats;
404 u32 reg_state, reg_cmd;
406 type = FIELD_GET(RKCANFD_REG_ERROR_CODE_TYPE, reg_ec);
407 reg_cmd = rkcanfd_read(priv, RKCANFD_REG_CMD);
408 reg_state = rkcanfd_read(priv, RKCANFD_REG_STATE);
410 netdev_dbg(priv->ndev, "%s Error in %s %s Phase: %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s(0x%08x) CMD=%u RX=%u TX=%u Error-Warning=%u Bus-Off=%u\n",
411 rkcanfd_get_error_type_str(type),
412 reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX ? "RX" : "TX",
413 reg_ec & RKCANFD_REG_ERROR_CODE_PHASE ? "Data" : "Arbitration",
414 RKCAN_ERROR_CODE(reg_ec, TX_OVERLOAD),
415 RKCAN_ERROR_CODE(reg_ec, TX_ERROR),
416 RKCAN_ERROR_CODE(reg_ec, TX_ACK),
417 RKCAN_ERROR_CODE(reg_ec, TX_ACK_EOF),
418 RKCAN_ERROR_CODE(reg_ec, TX_CRC),
419 RKCAN_ERROR_CODE(reg_ec, TX_STUFF_COUNT),
420 RKCAN_ERROR_CODE(reg_ec, TX_DATA),
421 RKCAN_ERROR_CODE(reg_ec, TX_SOF_DLC),
422 RKCAN_ERROR_CODE(reg_ec, TX_IDLE),
423 RKCAN_ERROR_CODE(reg_ec, RX_BUF_INT),
424 RKCAN_ERROR_CODE(reg_ec, RX_SPACE),
425 RKCAN_ERROR_CODE(reg_ec, RX_EOF),
426 RKCAN_ERROR_CODE(reg_ec, RX_ACK_LIM),
427 RKCAN_ERROR_CODE(reg_ec, RX_ACK),
428 RKCAN_ERROR_CODE(reg_ec, RX_CRC_LIM),
429 RKCAN_ERROR_CODE(reg_ec, RX_CRC),
430 RKCAN_ERROR_CODE(reg_ec, RX_STUFF_COUNT),
431 RKCAN_ERROR_CODE(reg_ec, RX_DATA),
432 RKCAN_ERROR_CODE(reg_ec, RX_DLC),
433 RKCAN_ERROR_CODE(reg_ec, RX_BRS_ESI),
434 RKCAN_ERROR_CODE(reg_ec, RX_RES),
435 RKCAN_ERROR_CODE(reg_ec, RX_FDF),
436 RKCAN_ERROR_CODE(reg_ec, RX_ID2_RTR),
437 RKCAN_ERROR_CODE(reg_ec, RX_SOF_IDE),
438 RKCAN_ERROR_CODE(reg_ec, RX_IDLE),
440 !!(reg_state & RKCANFD_REG_STATE_RX_PERIOD),
441 !!(reg_state & RKCANFD_REG_STATE_TX_PERIOD),
442 !!(reg_state & RKCANFD_REG_STATE_ERROR_WARNING_STATE),
443 !!(reg_state & RKCANFD_REG_STATE_BUS_OFF_STATE));
445 priv->can.can_stats.bus_error++;
447 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX)
455 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX) {
456 if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_SOF_IDE)
457 cf->data[3] = CAN_ERR_PROT_LOC_SOF;
458 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ID2_RTR)
459 cf->data[3] = CAN_ERR_PROT_LOC_RTR;
460 /* RKCANFD_REG_ERROR_CODE_RX_FDF */
461 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_RES)
462 cf->data[3] = CAN_ERR_PROT_LOC_RES0;
463 /* RKCANFD_REG_ERROR_CODE_RX_BRS_ESI */
464 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_DLC)
465 cf->data[3] = CAN_ERR_PROT_LOC_DLC;
466 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_DATA)
467 cf->data[3] = CAN_ERR_PROT_LOC_DATA;
468 /* RKCANFD_REG_ERROR_CODE_RX_STUFF_COUNT */
469 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_CRC)
470 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
471 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_CRC_LIM)
472 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL;
473 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ACK)
474 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
475 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ACK_LIM)
476 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL;
477 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_EOF)
478 cf->data[3] = CAN_ERR_PROT_LOC_EOF;
479 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_SPACE)
480 cf->data[3] = CAN_ERR_PROT_LOC_EOF;
481 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_BUF_INT)
482 cf->data[3] = CAN_ERR_PROT_LOC_INTERM;
484 cf->data[2] |= CAN_ERR_PROT_TX;
486 if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_SOF_DLC)
487 cf->data[3] = CAN_ERR_PROT_LOC_SOF;
488 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_DATA)
489 cf->data[3] = CAN_ERR_PROT_LOC_DATA;
490 /* RKCANFD_REG_ERROR_CODE_TX_STUFF_COUNT */
491 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_CRC)
492 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
493 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK_EOF)
494 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL;
495 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK)
496 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
497 /* RKCANFD_REG_ERROR_CODE_TX_ERROR */
498 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_OVERLOAD)
499 cf->data[2] |= CAN_ERR_PROT_OVERLOAD;
502 switch (reg_ec & RKCANFD_REG_ERROR_CODE_TYPE) {
503 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE,
504 RKCANFD_REG_ERROR_CODE_TYPE_BIT):
506 cf->data[2] |= CAN_ERR_PROT_BIT;
508 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE,
509 RKCANFD_REG_ERROR_CODE_TYPE_STUFF):
510 cf->data[2] |= CAN_ERR_PROT_STUFF;
512 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE,
513 RKCANFD_REG_ERROR_CODE_TYPE_FORM):
514 cf->data[2] |= CAN_ERR_PROT_FORM;
516 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE,
517 RKCANFD_REG_ERROR_CODE_TYPE_ACK):
518 cf->can_id |= CAN_ERR_ACK;
520 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE,
521 RKCANFD_REG_ERROR_CODE_TYPE_CRC):
522 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
527 static int rkcanfd_handle_error_int(struct rkcanfd_priv *priv)
529 struct net_device_stats *stats = &priv->ndev->stats;
530 struct can_frame *cf = NULL;
531 u32 reg_ec, timestamp;
535 reg_ec = rkcanfd_read(priv, RKCANFD_REG_ERROR_CODE);
540 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) {
541 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp);
543 struct can_berr_counter bec;
545 rkcanfd_get_berr_counter_corrected(priv, &bec);
546 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR | CAN_ERR_CNT;
547 cf->data[6] = bec.txerr;
548 cf->data[7] = bec.rxerr;
552 rkcanfd_handle_error_int_reg_ec(priv, cf, reg_ec);
557 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp);
559 stats->rx_fifo_errors++;
564 static int rkcanfd_handle_state_error_int(struct rkcanfd_priv *priv)
566 struct net_device_stats *stats = &priv->ndev->stats;
567 enum can_state new_state, rx_state, tx_state;
568 struct net_device *ndev = priv->ndev;
569 struct can_berr_counter bec;
570 struct can_frame *cf = NULL;
575 rkcanfd_get_berr_counter_corrected(priv, &bec);
576 can_state_get_by_berr_counter(ndev, &bec, &tx_state, &rx_state);
578 new_state = max(tx_state, rx_state);
579 if (new_state == priv->can.state)
582 /* The skb allocation might fail, but can_change_state()
583 * handles cf == NULL.
585 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp);
586 can_change_state(ndev, cf, tx_state, rx_state);
588 if (new_state == CAN_STATE_BUS_OFF) {
589 rkcanfd_chip_stop(priv, CAN_STATE_BUS_OFF);
596 if (new_state != CAN_STATE_BUS_OFF) {
597 cf->can_id |= CAN_ERR_CNT;
598 cf->data[6] = bec.txerr;
599 cf->data[7] = bec.rxerr;
602 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp);
604 stats->rx_fifo_errors++;
610 rkcanfd_handle_rx_fifo_overflow_int(struct rkcanfd_priv *priv)
612 struct net_device_stats *stats = &priv->ndev->stats;
613 struct can_berr_counter bec;
614 struct can_frame *cf = NULL;
619 stats->rx_over_errors++;
622 netdev_dbg(priv->ndev, "RX-FIFO overflow\n");
624 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp);
628 rkcanfd_get_berr_counter_corrected(priv, &bec);
630 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;
631 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
632 cf->data[6] = bec.txerr;
633 cf->data[7] = bec.rxerr;
635 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp);
637 stats->rx_fifo_errors++;
642 #define rkcanfd_handle(priv, irq, ...) \
644 struct rkcanfd_priv *_priv = (priv); \
647 err = rkcanfd_handle_##irq(_priv, ## __VA_ARGS__); \
649 netdev_err(_priv->ndev, \
650 "IRQ handler rkcanfd_handle_%s() returned error: %pe\n", \
651 __stringify(irq), ERR_PTR(err)); \
655 static irqreturn_t rkcanfd_irq(int irq, void *dev_id)
657 struct rkcanfd_priv *priv = dev_id;
658 u32 reg_int_unmasked, reg_int;
660 reg_int_unmasked = rkcanfd_read(priv, RKCANFD_REG_INT);
661 reg_int = reg_int_unmasked & ~priv->reg_int_mask_default;
666 /* First ACK then handle, to avoid lost-IRQ race condition on
667 * fast re-occurring interrupts.
669 rkcanfd_write(priv, RKCANFD_REG_INT, reg_int);
671 if (reg_int & RKCANFD_REG_INT_RX_FINISH_INT)
672 rkcanfd_handle(priv, rx_int);
674 if (reg_int & RKCANFD_REG_INT_ERROR_INT)
675 rkcanfd_handle(priv, error_int);
677 if (reg_int & (RKCANFD_REG_INT_BUS_OFF_INT |
678 RKCANFD_REG_INT_PASSIVE_ERROR_INT |
679 RKCANFD_REG_INT_ERROR_WARNING_INT) ||
680 priv->can.state > CAN_STATE_ERROR_ACTIVE)
681 rkcanfd_handle(priv, state_error_int);
683 if (reg_int & RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT)
684 rkcanfd_handle(priv, rx_fifo_overflow_int);
686 if (reg_int & ~(RKCANFD_REG_INT_ALL_ERROR |
687 RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT |
688 RKCANFD_REG_INT_RX_FINISH_INT))
689 netdev_err(priv->ndev, "%s: int=0x%08x\n", __func__, reg_int);
691 if (reg_int & RKCANFD_REG_INT_WAKEUP_INT)
692 netdev_info(priv->ndev, "%s: WAKEUP_INT\n", __func__);
694 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_FULL_INT)
695 netdev_info(priv->ndev, "%s: TXE_FIFO_FULL_INT\n", __func__);
697 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_OV_INT)
698 netdev_info(priv->ndev, "%s: TXE_FIFO_OV_INT\n", __func__);
700 if (reg_int & RKCANFD_REG_INT_BUS_OFF_RECOVERY_INT)
701 netdev_info(priv->ndev, "%s: BUS_OFF_RECOVERY_INT\n", __func__);
703 if (reg_int & RKCANFD_REG_INT_RX_FIFO_FULL_INT)
704 netdev_info(priv->ndev, "%s: RX_FIFO_FULL_INT\n", __func__);
706 if (reg_int & RKCANFD_REG_INT_OVERLOAD_INT)
707 netdev_info(priv->ndev, "%s: OVERLOAD_INT\n", __func__);
709 can_rx_offload_irq_finish(&priv->offload);
714 static int rkcanfd_open(struct net_device *ndev)
716 struct rkcanfd_priv *priv = netdev_priv(ndev);
719 err = open_candev(ndev);
723 err = pm_runtime_resume_and_get(ndev->dev.parent);
725 goto out_close_candev;
727 rkcanfd_chip_start(priv);
728 can_rx_offload_enable(&priv->offload);
730 err = request_irq(ndev->irq, rkcanfd_irq, IRQF_SHARED, ndev->name, priv);
732 goto out_rkcanfd_chip_stop;
734 rkcanfd_chip_interrupts_enable(priv);
736 netif_start_queue(ndev);
740 out_rkcanfd_chip_stop:
741 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED);
742 pm_runtime_put(ndev->dev.parent);
748 static int rkcanfd_stop(struct net_device *ndev)
750 struct rkcanfd_priv *priv = netdev_priv(ndev);
752 netif_stop_queue(ndev);
754 rkcanfd_chip_interrupts_disable(priv);
755 free_irq(ndev->irq, priv);
756 can_rx_offload_disable(&priv->offload);
757 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED);
760 pm_runtime_put(ndev->dev.parent);
765 static const struct net_device_ops rkcanfd_netdev_ops = {
766 .ndo_open = rkcanfd_open,
767 .ndo_stop = rkcanfd_stop,
768 .ndo_start_xmit = rkcanfd_start_xmit,
769 .ndo_change_mtu = can_change_mtu,
772 static int __maybe_unused rkcanfd_runtime_suspend(struct device *dev)
774 struct rkcanfd_priv *priv = dev_get_drvdata(dev);
776 clk_bulk_disable_unprepare(priv->clks_num, priv->clks);
781 static int __maybe_unused rkcanfd_runtime_resume(struct device *dev)
783 struct rkcanfd_priv *priv = dev_get_drvdata(dev);
785 return clk_bulk_prepare_enable(priv->clks_num, priv->clks);
788 static void rkcanfd_register_done(const struct rkcanfd_priv *priv)
792 dev_id = rkcanfd_read(priv, RKCANFD_REG_RTL_VERSION);
794 netdev_info(priv->ndev,
795 "Rockchip-CANFD %s rev%lu.%lu (errata 0x%04x) found\n",
796 rkcanfd_get_model_str(priv),
797 FIELD_GET(RKCANFD_REG_RTL_VERSION_MAJOR, dev_id),
798 FIELD_GET(RKCANFD_REG_RTL_VERSION_MINOR, dev_id),
799 priv->devtype_data.quirks);
801 if (priv->devtype_data.quirks & RKCANFD_QUIRK_RK3568_ERRATUM_5 &&
802 priv->can.clock.freq < RKCANFD_ERRATUM_5_SYSCLOCK_HZ_MIN)
803 netdev_info(priv->ndev,
804 "Erratum 5: CAN clock frequency (%luMHz) lower than known good (%luMHz), expect degraded performance\n",
805 priv->can.clock.freq / MEGA,
806 RKCANFD_ERRATUM_5_SYSCLOCK_HZ_MIN / MEGA);
809 static int rkcanfd_register(struct rkcanfd_priv *priv)
811 struct net_device *ndev = priv->ndev;
814 pm_runtime_enable(ndev->dev.parent);
816 err = pm_runtime_resume_and_get(ndev->dev.parent);
818 goto out_pm_runtime_disable;
820 rkcanfd_ethtool_init(priv);
822 err = register_candev(ndev);
824 goto out_pm_runtime_put_sync;
826 rkcanfd_register_done(priv);
828 pm_runtime_put(ndev->dev.parent);
832 out_pm_runtime_put_sync:
833 pm_runtime_put_sync(ndev->dev.parent);
834 out_pm_runtime_disable:
835 pm_runtime_disable(ndev->dev.parent);
840 static inline void rkcanfd_unregister(struct rkcanfd_priv *priv)
842 struct net_device *ndev = priv->ndev;
844 unregister_candev(ndev);
845 pm_runtime_disable(ndev->dev.parent);
848 static const struct of_device_id rkcanfd_of_match[] = {
850 .compatible = "rockchip,rk3568v2-canfd",
851 .data = &rkcanfd_devtype_data_rk3568v2,
853 .compatible = "rockchip,rk3568v3-canfd",
854 .data = &rkcanfd_devtype_data_rk3568v3,
859 MODULE_DEVICE_TABLE(of, rkcanfd_of_match);
861 static int rkcanfd_probe(struct platform_device *pdev)
863 struct rkcanfd_priv *priv;
864 struct net_device *ndev;
868 ndev = alloc_candev(sizeof(struct rkcanfd_priv), RKCANFD_TXFIFO_DEPTH);
872 priv = netdev_priv(ndev);
874 ndev->irq = platform_get_irq(pdev, 0);
877 goto out_free_candev;
880 priv->clks_num = devm_clk_bulk_get_all(&pdev->dev, &priv->clks);
881 if (priv->clks_num < 0) {
882 err = priv->clks_num;
883 goto out_free_candev;
886 priv->regs = devm_platform_ioremap_resource(pdev, 0);
887 if (IS_ERR(priv->regs)) {
888 err = PTR_ERR(priv->regs);
889 goto out_free_candev;
892 priv->reset = devm_reset_control_array_get_exclusive(&pdev->dev);
893 if (IS_ERR(priv->reset)) {
894 err = dev_err_probe(&pdev->dev, PTR_ERR(priv->reset),
895 "Failed to get reset line\n");
896 goto out_free_candev;
899 SET_NETDEV_DEV(ndev, &pdev->dev);
901 ndev->netdev_ops = &rkcanfd_netdev_ops;
902 ndev->flags |= IFF_ECHO;
904 platform_set_drvdata(pdev, priv);
905 priv->can.clock.freq = clk_get_rate(priv->clks[0].clk);
906 priv->can.bittiming_const = &rkcanfd_bittiming_const;
907 priv->can.data_bittiming_const = &rkcanfd_data_bittiming_const;
908 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
909 CAN_CTRLMODE_BERR_REPORTING;
910 if (!(priv->devtype_data.quirks & RKCANFD_QUIRK_CANFD_BROKEN))
911 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD;
912 priv->can.do_set_mode = rkcanfd_set_mode;
913 priv->can.do_get_berr_counter = rkcanfd_get_berr_counter;
916 match = device_get_match_data(&pdev->dev);
918 priv->devtype_data = *(struct rkcanfd_devtype_data *)match;
920 err = can_rx_offload_add_manual(ndev, &priv->offload,
921 RKCANFD_NAPI_WEIGHT);
923 goto out_free_candev;
925 err = rkcanfd_register(priv);
927 goto out_can_rx_offload_del;
931 out_can_rx_offload_del:
932 can_rx_offload_del(&priv->offload);
939 static void rkcanfd_remove(struct platform_device *pdev)
941 struct rkcanfd_priv *priv = platform_get_drvdata(pdev);
942 struct net_device *ndev = priv->ndev;
944 can_rx_offload_del(&priv->offload);
945 rkcanfd_unregister(priv);
949 static const struct dev_pm_ops rkcanfd_pm_ops = {
950 SET_RUNTIME_PM_OPS(rkcanfd_runtime_suspend,
951 rkcanfd_runtime_resume, NULL)
954 static struct platform_driver rkcanfd_driver = {
957 .pm = &rkcanfd_pm_ops,
958 .of_match_table = rkcanfd_of_match,
960 .probe = rkcanfd_probe,
961 .remove = rkcanfd_remove,
963 module_platform_driver(rkcanfd_driver);
966 MODULE_DESCRIPTION("Rockchip CAN-FD Driver");
967 MODULE_LICENSE("GPL");