968 lines · c
1// SPDX-License-Identifier: GPL-2.02//3// Copyright (c) 2023, 2024 Pengutronix,4// Marc Kleine-Budde <kernel@pengutronix.de>5//6// Based on:7//8// Rockchip CANFD driver9//10// Copyright (c) 2020 Rockchip Electronics Co. Ltd.11//12 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>19#include <linux/of.h>20#include <linux/of_device.h>21#include <linux/platform_device.h>22#include <linux/pm_runtime.h>23#include <linux/string.h>24 25#include "rockchip_canfd.h"26 27static 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,36};37 38/* The rk3568 CAN-FD errata sheet as of Tue 07 Nov 2023 11:25:31 +08:0039 * states that only the rk3568v2 is affected by erratum 5, but tests40 * with the rk3568v2 and rk3568v3 show that the RX_FIFO_CNT is41 * sometimes too high. In contrast to the errata sheet mark rk3568v342 * as effected by erratum 5, too.43 */44static 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,51};52 53static const char *__rkcanfd_get_model_str(enum rkcanfd_model model)54{55 switch (model) {56 case RKCANFD_MODEL_RK3568V2:57 return "rk3568v2";58 case RKCANFD_MODEL_RK3568V3:59 return "rk3568v3";60 }61 62 return "<unknown>";63}64 65static inline const char *66rkcanfd_get_model_str(const struct rkcanfd_priv *priv)67{68 return __rkcanfd_get_model_str(priv->devtype_data.model);69}70 71/* Note:72 *73 * The formula to calculate the CAN System Clock is:74 *75 * Tsclk = 2 x Tclk x (brp + 1)76 *77 * Double the data sheet's brp_min, brp_max and brp_inc values (both78 * for the arbitration and data bit timing) to take the "2 x" into79 * account.80 */81static const struct can_bittiming_const rkcanfd_bittiming_const = {82 .name = DEVICE_NAME,83 .tseg1_min = 1,84 .tseg1_max = 256,85 .tseg2_min = 1,86 .tseg2_max = 128,87 .sjw_max = 128,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 */91};92 93static const struct can_bittiming_const rkcanfd_data_bittiming_const = {94 .name = DEVICE_NAME,95 .tseg1_min = 1,96 .tseg1_max = 32,97 .tseg2_min = 1,98 .tseg2_max = 16,99 .sjw_max = 16,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 */103};104 105static void rkcanfd_chip_set_reset_mode(const struct rkcanfd_priv *priv)106{107 reset_control_assert(priv->reset);108 udelay(2);109 reset_control_deassert(priv->reset);110 111 rkcanfd_write(priv, RKCANFD_REG_MODE, 0x0);112}113 114static void rkcanfd_chip_set_work_mode(const struct rkcanfd_priv *priv)115{116 rkcanfd_write(priv, RKCANFD_REG_MODE, priv->reg_mode_default);117}118 119static int rkcanfd_set_bittiming(struct rkcanfd_priv *priv)120{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;124 u32 tdco;125 126 reg_nbt = FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_SJW,127 bt->sjw - 1) |128 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_BRP,129 (bt->brp / 2) - 1) |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);134 135 rkcanfd_write(priv, RKCANFD_REG_FD_NOMINAL_BITTIMING, reg_nbt);136 137 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))138 return 0;139 140 reg_dbt = FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_SJW,141 dbt->sjw - 1) |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);148 149 rkcanfd_write(priv, RKCANFD_REG_FD_DATA_BITTIMING, reg_dbt);150 151 tdco = (priv->can.clock.freq / dbt->bitrate) * 2 / 3;152 tdco = min(tdco, FIELD_MAX(RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_OFFSET));153 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,157 reg_tdc);158 159 return 0;160}161 162static void rkcanfd_get_berr_counter_corrected(struct rkcanfd_priv *priv,163 struct can_berr_counter *bec)164{165 struct can_berr_counter bec_raw;166 u32 reg_state;167 168 bec->rxerr = rkcanfd_read(priv, RKCANFD_REG_RXERRORCNT);169 bec->txerr = rkcanfd_read(priv, RKCANFD_REG_TXERRORCNT);170 bec_raw = *bec;171 172 /* Tests show that sometimes both CAN bus error counters read173 * 0x0, even if the controller is in warning mode174 * (RKCANFD_REG_STATE_ERROR_WARNING_STATE in RKCANFD_REG_STATE175 * set).176 *177 * In case both error counters read 0x0, use the struct178 * priv->bec, otherwise save the read value to priv->bec.179 *180 * rkcanfd_handle_rx_int_one() handles the decrementing of181 * priv->bec.rxerr for successfully RX'ed CAN frames.182 *183 * Luckily the controller doesn't decrement the RX CAN bus184 * error counter in hardware for self received TX'ed CAN185 * frames (RKCANFD_REG_MODE_RXSTX_MODE), so RXSTX doesn't186 * interfere with proper RX CAN bus error counters.187 *188 * rkcanfd_handle_tx_done_one() handles the decrementing of189 * priv->bec.txerr for successfully TX'ed CAN frames.190 */191 if (!bec->rxerr && !bec->txerr)192 *bec = priv->bec;193 else194 priv->bec = *bec;195 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",199 __func__,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));203}204 205static int rkcanfd_get_berr_counter(const struct net_device *ndev,206 struct can_berr_counter *bec)207{208 struct rkcanfd_priv *priv = netdev_priv(ndev);209 int err;210 211 err = pm_runtime_resume_and_get(ndev->dev.parent);212 if (err)213 return err;214 215 rkcanfd_get_berr_counter_corrected(priv, bec);216 217 pm_runtime_put(ndev->dev.parent);218 219 return 0;220}221 222static void rkcanfd_chip_interrupts_enable(const struct rkcanfd_priv *priv)223{224 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, priv->reg_int_mask_default);225 226 netdev_dbg(priv->ndev, "%s: reg_int_mask=0x%08x\n", __func__,227 rkcanfd_read(priv, RKCANFD_REG_INT_MASK));228}229 230static void rkcanfd_chip_interrupts_disable(const struct rkcanfd_priv *priv)231{232 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, RKCANFD_REG_INT_ALL);233}234 235static void rkcanfd_chip_fifo_setup(struct rkcanfd_priv *priv)236{237 u32 reg;238 239 /* TXE FIFO */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);243 244 /* RX FIFO */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);248 249 WRITE_ONCE(priv->tx_head, 0);250 WRITE_ONCE(priv->tx_tail, 0);251 netdev_reset_queue(priv->ndev);252}253 254static void rkcanfd_chip_start(struct rkcanfd_priv *priv)255{256 u32 reg;257 258 rkcanfd_chip_set_reset_mode(priv);259 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);263 264 /* enable:265 * - CAN_FD: enable CAN-FD266 * - AUTO_RETX_MODE: auto retransmission on TX error267 * - COVER_MODE: RX-FIFO overwrite mode, do not send OVERLOAD frames268 * - RXSTX_MODE: Receive Self Transmit data mode269 * - WORK_MODE: transition from reset to working mode270 */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;278 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;283 284 /* mask, i.e. ignore:285 * - TIMESTAMP_COUNTER_OVERFLOW_INT - timestamp counter overflow interrupt286 * - TX_ARBIT_FAIL_INT - TX arbitration fail interrupt287 * - OVERLOAD_INT - CAN bus overload interrupt288 * - TX_FINISH_INT - Transmit finish interrupt289 */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;295 296 /* Do not mask the bus error interrupt if the bus error297 * reporting is requested.298 */299 if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING))300 priv->reg_int_mask_default |= RKCANFD_REG_INT_ERROR_INT;301 302 memset(&priv->bec, 0x0, sizeof(priv->bec));303 304 rkcanfd_chip_fifo_setup(priv);305 rkcanfd_timestamp_init(priv);306 rkcanfd_timestamp_start(priv);307 308 rkcanfd_set_bittiming(priv);309 310 rkcanfd_chip_interrupts_disable(priv);311 rkcanfd_chip_set_work_mode(priv);312 313 priv->can.state = CAN_STATE_ERROR_ACTIVE;314 315 netdev_dbg(priv->ndev, "%s: reg_mode=0x%08x\n", __func__,316 rkcanfd_read(priv, RKCANFD_REG_MODE));317}318 319static void __rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state)320{321 priv->can.state = state;322 323 rkcanfd_chip_set_reset_mode(priv);324 rkcanfd_chip_interrupts_disable(priv);325}326 327static void rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state)328{329 priv->can.state = state;330 331 rkcanfd_timestamp_stop(priv);332 __rkcanfd_chip_stop(priv, state);333}334 335static void rkcanfd_chip_stop_sync(struct rkcanfd_priv *priv, const enum can_state state)336{337 priv->can.state = state;338 339 rkcanfd_timestamp_stop_sync(priv);340 __rkcanfd_chip_stop(priv, state);341}342 343static int rkcanfd_set_mode(struct net_device *ndev,344 enum can_mode mode)345{346 struct rkcanfd_priv *priv = netdev_priv(ndev);347 348 switch (mode) {349 case CAN_MODE_START:350 rkcanfd_chip_start(priv);351 rkcanfd_chip_interrupts_enable(priv);352 netif_wake_queue(ndev);353 break;354 355 default:356 return -EOPNOTSUPP;357 }358 359 return 0;360}361 362static struct sk_buff *363rkcanfd_alloc_can_err_skb(struct rkcanfd_priv *priv,364 struct can_frame **cf, u32 *timestamp)365{366 struct sk_buff *skb;367 368 *timestamp = rkcanfd_get_timestamp(priv);369 370 skb = alloc_can_err_skb(priv->ndev, cf);371 if (skb)372 rkcanfd_skb_set_timestamp(priv, skb, *timestamp);373 374 return skb;375}376 377static const char *rkcanfd_get_error_type_str(unsigned int type)378{379 switch (type) {380 case RKCANFD_REG_ERROR_CODE_TYPE_BIT:381 return "Bit";382 case RKCANFD_REG_ERROR_CODE_TYPE_STUFF:383 return "Stuff";384 case RKCANFD_REG_ERROR_CODE_TYPE_FORM:385 return "Form";386 case RKCANFD_REG_ERROR_CODE_TYPE_ACK:387 return "ACK";388 case RKCANFD_REG_ERROR_CODE_TYPE_CRC:389 return "CRC";390 }391 392 return "<unknown>";393}394 395#define RKCAN_ERROR_CODE(reg_ec, code) \396 ((reg_ec) & RKCANFD_REG_ERROR_CODE_##code ? __stringify(code) " " : "")397 398static void399rkcanfd_handle_error_int_reg_ec(struct rkcanfd_priv *priv, struct can_frame *cf,400 const u32 reg_ec)401{402 struct net_device_stats *stats = &priv->ndev->stats;403 unsigned int type;404 u32 reg_state, reg_cmd;405 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);409 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),439 reg_ec, reg_cmd,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));444 445 priv->can.can_stats.bus_error++;446 447 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX)448 stats->rx_errors++;449 else450 stats->tx_errors++;451 452 if (!cf)453 return;454 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;483 } else {484 cf->data[2] |= CAN_ERR_PROT_TX;485 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;500 }501 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):505 506 cf->data[2] |= CAN_ERR_PROT_BIT;507 break;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;511 break;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;515 break;516 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE,517 RKCANFD_REG_ERROR_CODE_TYPE_ACK):518 cf->can_id |= CAN_ERR_ACK;519 break;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;523 break;524 }525}526 527static int rkcanfd_handle_error_int(struct rkcanfd_priv *priv)528{529 struct net_device_stats *stats = &priv->ndev->stats;530 struct can_frame *cf = NULL;531 u32 reg_ec, timestamp;532 struct sk_buff *skb;533 int err;534 535 reg_ec = rkcanfd_read(priv, RKCANFD_REG_ERROR_CODE);536 537 if (!reg_ec)538 return 0;539 540 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) {541 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp);542 if (cf) {543 struct can_berr_counter bec;544 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;549 }550 }551 552 rkcanfd_handle_error_int_reg_ec(priv, cf, reg_ec);553 554 if (!cf)555 return 0;556 557 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp);558 if (err)559 stats->rx_fifo_errors++;560 561 return 0;562}563 564static int rkcanfd_handle_state_error_int(struct rkcanfd_priv *priv)565{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;571 struct sk_buff *skb;572 u32 timestamp;573 int err;574 575 rkcanfd_get_berr_counter_corrected(priv, &bec);576 can_state_get_by_berr_counter(ndev, &bec, &tx_state, &rx_state);577 578 new_state = max(tx_state, rx_state);579 if (new_state == priv->can.state)580 return 0;581 582 /* The skb allocation might fail, but can_change_state()583 * handles cf == NULL.584 */585 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp);586 can_change_state(ndev, cf, tx_state, rx_state);587 588 if (new_state == CAN_STATE_BUS_OFF) {589 rkcanfd_chip_stop(priv, CAN_STATE_BUS_OFF);590 can_bus_off(ndev);591 }592 593 if (!skb)594 return 0;595 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;600 }601 602 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp);603 if (err)604 stats->rx_fifo_errors++;605 606 return 0;607}608 609static int610rkcanfd_handle_rx_fifo_overflow_int(struct rkcanfd_priv *priv)611{612 struct net_device_stats *stats = &priv->ndev->stats;613 struct can_berr_counter bec;614 struct can_frame *cf = NULL;615 struct sk_buff *skb;616 u32 timestamp;617 int err;618 619 stats->rx_over_errors++;620 stats->rx_errors++;621 622 netdev_dbg(priv->ndev, "RX-FIFO overflow\n");623 624 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp);625 if (skb)626 return 0;627 628 rkcanfd_get_berr_counter_corrected(priv, &bec);629 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;634 635 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp);636 if (err)637 stats->rx_fifo_errors++;638 639 return 0;640}641 642#define rkcanfd_handle(priv, irq, ...) \643({ \644 struct rkcanfd_priv *_priv = (priv); \645 int err; \646\647 err = rkcanfd_handle_##irq(_priv, ## __VA_ARGS__); \648 if (err) \649 netdev_err(_priv->ndev, \650 "IRQ handler rkcanfd_handle_%s() returned error: %pe\n", \651 __stringify(irq), ERR_PTR(err)); \652 err; \653})654 655static irqreturn_t rkcanfd_irq(int irq, void *dev_id)656{657 struct rkcanfd_priv *priv = dev_id;658 u32 reg_int_unmasked, reg_int;659 660 reg_int_unmasked = rkcanfd_read(priv, RKCANFD_REG_INT);661 reg_int = reg_int_unmasked & ~priv->reg_int_mask_default;662 663 if (!reg_int)664 return IRQ_NONE;665 666 /* First ACK then handle, to avoid lost-IRQ race condition on667 * fast re-occurring interrupts.668 */669 rkcanfd_write(priv, RKCANFD_REG_INT, reg_int);670 671 if (reg_int & RKCANFD_REG_INT_RX_FINISH_INT)672 rkcanfd_handle(priv, rx_int);673 674 if (reg_int & RKCANFD_REG_INT_ERROR_INT)675 rkcanfd_handle(priv, error_int);676 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);682 683 if (reg_int & RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT)684 rkcanfd_handle(priv, rx_fifo_overflow_int);685 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);690 691 if (reg_int & RKCANFD_REG_INT_WAKEUP_INT)692 netdev_info(priv->ndev, "%s: WAKEUP_INT\n", __func__);693 694 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_FULL_INT)695 netdev_info(priv->ndev, "%s: TXE_FIFO_FULL_INT\n", __func__);696 697 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_OV_INT)698 netdev_info(priv->ndev, "%s: TXE_FIFO_OV_INT\n", __func__);699 700 if (reg_int & RKCANFD_REG_INT_BUS_OFF_RECOVERY_INT)701 netdev_info(priv->ndev, "%s: BUS_OFF_RECOVERY_INT\n", __func__);702 703 if (reg_int & RKCANFD_REG_INT_RX_FIFO_FULL_INT)704 netdev_info(priv->ndev, "%s: RX_FIFO_FULL_INT\n", __func__);705 706 if (reg_int & RKCANFD_REG_INT_OVERLOAD_INT)707 netdev_info(priv->ndev, "%s: OVERLOAD_INT\n", __func__);708 709 can_rx_offload_irq_finish(&priv->offload);710 711 return IRQ_HANDLED;712}713 714static int rkcanfd_open(struct net_device *ndev)715{716 struct rkcanfd_priv *priv = netdev_priv(ndev);717 int err;718 719 err = open_candev(ndev);720 if (err)721 return err;722 723 err = pm_runtime_resume_and_get(ndev->dev.parent);724 if (err)725 goto out_close_candev;726 727 rkcanfd_chip_start(priv);728 can_rx_offload_enable(&priv->offload);729 730 err = request_irq(ndev->irq, rkcanfd_irq, IRQF_SHARED, ndev->name, priv);731 if (err)732 goto out_rkcanfd_chip_stop;733 734 rkcanfd_chip_interrupts_enable(priv);735 736 netif_start_queue(ndev);737 738 return 0;739 740out_rkcanfd_chip_stop:741 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED);742 pm_runtime_put(ndev->dev.parent);743out_close_candev:744 close_candev(ndev);745 return err;746}747 748static int rkcanfd_stop(struct net_device *ndev)749{750 struct rkcanfd_priv *priv = netdev_priv(ndev);751 752 netif_stop_queue(ndev);753 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);758 close_candev(ndev);759 760 pm_runtime_put(ndev->dev.parent);761 762 return 0;763}764 765static 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,770};771 772static int __maybe_unused rkcanfd_runtime_suspend(struct device *dev)773{774 struct rkcanfd_priv *priv = dev_get_drvdata(dev);775 776 clk_bulk_disable_unprepare(priv->clks_num, priv->clks);777 778 return 0;779}780 781static int __maybe_unused rkcanfd_runtime_resume(struct device *dev)782{783 struct rkcanfd_priv *priv = dev_get_drvdata(dev);784 785 return clk_bulk_prepare_enable(priv->clks_num, priv->clks);786}787 788static void rkcanfd_register_done(const struct rkcanfd_priv *priv)789{790 u32 dev_id;791 792 dev_id = rkcanfd_read(priv, RKCANFD_REG_RTL_VERSION);793 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);800 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);807}808 809static int rkcanfd_register(struct rkcanfd_priv *priv)810{811 struct net_device *ndev = priv->ndev;812 int err;813 814 pm_runtime_enable(ndev->dev.parent);815 816 err = pm_runtime_resume_and_get(ndev->dev.parent);817 if (err)818 goto out_pm_runtime_disable;819 820 rkcanfd_ethtool_init(priv);821 822 err = register_candev(ndev);823 if (err)824 goto out_pm_runtime_put_sync;825 826 rkcanfd_register_done(priv);827 828 pm_runtime_put(ndev->dev.parent);829 830 return 0;831 832out_pm_runtime_put_sync:833 pm_runtime_put_sync(ndev->dev.parent);834out_pm_runtime_disable:835 pm_runtime_disable(ndev->dev.parent);836 837 return err;838}839 840static inline void rkcanfd_unregister(struct rkcanfd_priv *priv)841{842 struct net_device *ndev = priv->ndev;843 844 unregister_candev(ndev);845 pm_runtime_disable(ndev->dev.parent);846}847 848static const struct of_device_id rkcanfd_of_match[] = {849 {850 .compatible = "rockchip,rk3568v2-canfd",851 .data = &rkcanfd_devtype_data_rk3568v2,852 }, {853 .compatible = "rockchip,rk3568v3-canfd",854 .data = &rkcanfd_devtype_data_rk3568v3,855 }, {856 /* sentinel */857 },858};859MODULE_DEVICE_TABLE(of, rkcanfd_of_match);860 861static int rkcanfd_probe(struct platform_device *pdev)862{863 struct rkcanfd_priv *priv;864 struct net_device *ndev;865 const void *match;866 int err;867 868 ndev = alloc_candev(sizeof(struct rkcanfd_priv), RKCANFD_TXFIFO_DEPTH);869 if (!ndev)870 return -ENOMEM;871 872 priv = netdev_priv(ndev);873 874 ndev->irq = platform_get_irq(pdev, 0);875 if (ndev->irq < 0) {876 err = ndev->irq;877 goto out_free_candev;878 }879 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;884 }885 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;890 }891 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;897 }898 899 SET_NETDEV_DEV(ndev, &pdev->dev);900 901 ndev->netdev_ops = &rkcanfd_netdev_ops;902 ndev->flags |= IFF_ECHO;903 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;914 priv->ndev = ndev;915 916 match = device_get_match_data(&pdev->dev);917 if (match)918 priv->devtype_data = *(struct rkcanfd_devtype_data *)match;919 920 err = can_rx_offload_add_manual(ndev, &priv->offload,921 RKCANFD_NAPI_WEIGHT);922 if (err)923 goto out_free_candev;924 925 err = rkcanfd_register(priv);926 if (err)927 goto out_can_rx_offload_del;928 929 return 0;930 931out_can_rx_offload_del:932 can_rx_offload_del(&priv->offload);933out_free_candev:934 free_candev(ndev);935 936 return err;937}938 939static void rkcanfd_remove(struct platform_device *pdev)940{941 struct rkcanfd_priv *priv = platform_get_drvdata(pdev);942 struct net_device *ndev = priv->ndev;943 944 can_rx_offload_del(&priv->offload);945 rkcanfd_unregister(priv);946 free_candev(ndev);947}948 949static const struct dev_pm_ops rkcanfd_pm_ops = {950 SET_RUNTIME_PM_OPS(rkcanfd_runtime_suspend,951 rkcanfd_runtime_resume, NULL)952};953 954static struct platform_driver rkcanfd_driver = {955 .driver = {956 .name = DEVICE_NAME,957 .pm = &rkcanfd_pm_ops,958 .of_match_table = rkcanfd_of_match,959 },960 .probe = rkcanfd_probe,961 .remove = rkcanfd_remove,962};963module_platform_driver(rkcanfd_driver);964 965MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>");966MODULE_DESCRIPTION("Rockchip CAN-FD Driver");967MODULE_LICENSE("GPL");968