1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright (c) 2023, 2024 Pengutronix, 4 // Marc Kleine-Budde <kernel@pengutronix.de> 5 // 6 // Based on: 7 // 8 // Rockchip CANFD driver 9 // 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 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, 36 }; 37 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. 43 */ 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, 51 }; 52 53 static const struct rkcanfd_devtype_data rkcanfd_devtype_data_rk3588 = { 54 .model = RKCANFD_MODEL_RK3588, 55 .quirks = RKCANFD_QUIRK_RK3568_ERRATUM_5 | 56 RKCANFD_QUIRK_RK3568_ERRATUM_6, 57 }; 58 59 static const char *__rkcanfd_get_model_str(enum rkcanfd_model model) 60 { 61 switch (model) { 62 case RKCANFD_MODEL_RK3568V2: 63 return "rk3568v2"; 64 case RKCANFD_MODEL_RK3568V3: 65 return "rk3568v3"; 66 case RKCANFD_MODEL_RK3588: 67 return "rk3588"; 68 } 69 70 return "<unknown>"; 71 } 72 73 static inline const char * 74 rkcanfd_get_model_str(const struct rkcanfd_priv *priv) 75 { 76 return __rkcanfd_get_model_str(priv->devtype_data.model); 77 } 78 79 /* Note: 80 * 81 * The formula to calculate the CAN System Clock is: 82 * 83 * Tsclk = 2 x Tclk x (brp + 1) 84 * 85 * Double the data sheet's brp_min, brp_max and brp_inc values (both 86 * for the arbitration and data bit timing) to take the "2 x" into 87 * account. 88 */ 89 static const struct can_bittiming_const rkcanfd_bittiming_const = { 90 .name = DEVICE_NAME, 91 .tseg1_min = 1, 92 .tseg1_max = 256, 93 .tseg2_min = 1, 94 .tseg2_max = 128, 95 .sjw_max = 128, 96 .brp_min = 2, /* value from data sheet x2 */ 97 .brp_max = 512, /* value from data sheet x2 */ 98 .brp_inc = 2, /* value from data sheet x2 */ 99 }; 100 101 static const struct can_bittiming_const rkcanfd_data_bittiming_const = { 102 .name = DEVICE_NAME, 103 .tseg1_min = 1, 104 .tseg1_max = 32, 105 .tseg2_min = 1, 106 .tseg2_max = 16, 107 .sjw_max = 16, 108 .brp_min = 2, /* value from data sheet x2 */ 109 .brp_max = 512, /* value from data sheet x2 */ 110 .brp_inc = 2, /* value from data sheet x2 */ 111 }; 112 113 static void rkcanfd_chip_set_reset_mode(const struct rkcanfd_priv *priv) 114 { 115 reset_control_assert(priv->reset); 116 udelay(2); 117 reset_control_deassert(priv->reset); 118 119 rkcanfd_write(priv, RKCANFD_REG_MODE, 0x0); 120 } 121 122 static void rkcanfd_chip_set_work_mode(const struct rkcanfd_priv *priv) 123 { 124 rkcanfd_write(priv, RKCANFD_REG_MODE, priv->reg_mode_default); 125 } 126 127 static int rkcanfd_set_bittiming(struct rkcanfd_priv *priv) 128 { 129 const struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 130 const struct can_bittiming *bt = &priv->can.bittiming; 131 u32 reg_nbt, reg_dbt, reg_tdc; 132 u32 tdco; 133 134 reg_nbt = FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_SJW, 135 bt->sjw - 1) | 136 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_BRP, 137 (bt->brp / 2) - 1) | 138 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_TSEG2, 139 bt->phase_seg2 - 1) | 140 FIELD_PREP(RKCANFD_REG_FD_NOMINAL_BITTIMING_TSEG1, 141 bt->prop_seg + bt->phase_seg1 - 1); 142 143 rkcanfd_write(priv, RKCANFD_REG_FD_NOMINAL_BITTIMING, reg_nbt); 144 145 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD)) 146 return 0; 147 148 reg_dbt = FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_SJW, 149 dbt->sjw - 1) | 150 FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_BRP, 151 (dbt->brp / 2) - 1) | 152 FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_TSEG2, 153 dbt->phase_seg2 - 1) | 154 FIELD_PREP(RKCANFD_REG_FD_DATA_BITTIMING_TSEG1, 155 dbt->prop_seg + dbt->phase_seg1 - 1); 156 157 rkcanfd_write(priv, RKCANFD_REG_FD_DATA_BITTIMING, reg_dbt); 158 159 /* RK3588 CAN-FD BRS works with TDC disabled. */ 160 if (priv->devtype_data.model == RKCANFD_MODEL_RK3588) { 161 rkcanfd_write(priv, RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION, 0); 162 return 0; 163 } 164 165 tdco = (priv->can.clock.freq / dbt->bitrate) * 2 / 3; 166 tdco = min(tdco, FIELD_MAX(RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_OFFSET)); 167 168 reg_tdc = FIELD_PREP(RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_OFFSET, tdco) | 169 RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION_TDC_ENABLE; 170 rkcanfd_write(priv, RKCANFD_REG_TRANSMIT_DELAY_COMPENSATION, 171 reg_tdc); 172 173 return 0; 174 } 175 176 static void rkcanfd_get_berr_counter_corrected(struct rkcanfd_priv *priv, 177 struct can_berr_counter *bec) 178 { 179 struct can_berr_counter bec_raw; 180 u32 reg_state; 181 182 bec->rxerr = rkcanfd_read(priv, RKCANFD_REG_RXERRORCNT); 183 bec->txerr = rkcanfd_read(priv, RKCANFD_REG_TXERRORCNT); 184 bec_raw = *bec; 185 186 /* Tests show that sometimes both CAN bus error counters read 187 * 0x0, even if the controller is in warning mode 188 * (RKCANFD_REG_STATE_ERROR_WARNING_STATE in RKCANFD_REG_STATE 189 * set). 190 * 191 * In case both error counters read 0x0, use the struct 192 * priv->bec, otherwise save the read value to priv->bec. 193 * 194 * rkcanfd_handle_rx_int_one() handles the decrementing of 195 * priv->bec.rxerr for successfully RX'ed CAN frames. 196 * 197 * Luckily the controller doesn't decrement the RX CAN bus 198 * error counter in hardware for self received TX'ed CAN 199 * frames (RKCANFD_REG_MODE_RXSTX_MODE), so RXSTX doesn't 200 * interfere with proper RX CAN bus error counters. 201 * 202 * rkcanfd_handle_tx_done_one() handles the decrementing of 203 * priv->bec.txerr for successfully TX'ed CAN frames. 204 */ 205 if (!bec->rxerr && !bec->txerr) 206 *bec = priv->bec; 207 else 208 priv->bec = *bec; 209 210 reg_state = rkcanfd_read(priv, RKCANFD_REG_STATE); 211 netdev_vdbg(priv->ndev, 212 "%s: Raw/Cor: txerr=%3u/%3u rxerr=%3u/%3u Bus Off=%u Warning=%u\n", 213 __func__, 214 bec_raw.txerr, bec->txerr, bec_raw.rxerr, bec->rxerr, 215 !!(reg_state & RKCANFD_REG_STATE_BUS_OFF_STATE), 216 !!(reg_state & RKCANFD_REG_STATE_ERROR_WARNING_STATE)); 217 } 218 219 static int rkcanfd_get_berr_counter(const struct net_device *ndev, 220 struct can_berr_counter *bec) 221 { 222 struct rkcanfd_priv *priv = netdev_priv(ndev); 223 int err; 224 225 err = pm_runtime_resume_and_get(ndev->dev.parent); 226 if (err) 227 return err; 228 229 rkcanfd_get_berr_counter_corrected(priv, bec); 230 231 pm_runtime_put(ndev->dev.parent); 232 233 return 0; 234 } 235 236 static void rkcanfd_chip_interrupts_enable(const struct rkcanfd_priv *priv) 237 { 238 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, priv->reg_int_mask_default); 239 240 netdev_dbg(priv->ndev, "%s: reg_int_mask=0x%08x\n", __func__, 241 rkcanfd_read(priv, RKCANFD_REG_INT_MASK)); 242 } 243 244 static void rkcanfd_chip_interrupts_disable(const struct rkcanfd_priv *priv) 245 { 246 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, RKCANFD_REG_INT_ALL); 247 } 248 249 static void rkcanfd_chip_fifo_setup(struct rkcanfd_priv *priv) 250 { 251 u32 reg; 252 253 /* RX FIFO */ 254 reg = rkcanfd_read(priv, RKCANFD_REG_RX_FIFO_CTRL); 255 reg |= RKCANFD_REG_RX_FIFO_CTRL_RX_FIFO_ENABLE; 256 rkcanfd_write(priv, RKCANFD_REG_RX_FIFO_CTRL, reg); 257 258 WRITE_ONCE(priv->tx_head, 0); 259 WRITE_ONCE(priv->tx_tail, 0); 260 netdev_reset_queue(priv->ndev); 261 } 262 263 static void rkcanfd_chip_start(struct rkcanfd_priv *priv) 264 { 265 u32 reg; 266 267 rkcanfd_chip_set_reset_mode(priv); 268 269 /* Receiving Filter: accept all */ 270 rkcanfd_write(priv, RKCANFD_REG_IDCODE, 0x0); 271 rkcanfd_write(priv, RKCANFD_REG_IDMASK, RKCANFD_REG_IDCODE_EXTENDED_FRAME_ID); 272 273 /* enable: 274 * - CAN_FD: enable CAN-FD 275 * - AUTO_RETX_MODE: auto retransmission on TX error 276 * - COVER_MODE: RX-FIFO overwrite mode, do not send OVERLOAD frames 277 * - RXSTX_MODE: Receive Self Transmit data mode 278 * - WORK_MODE: transition from reset to working mode 279 */ 280 reg = rkcanfd_read(priv, RKCANFD_REG_MODE); 281 priv->reg_mode_default = reg | 282 RKCANFD_REG_MODE_CAN_FD_MODE_ENABLE | 283 RKCANFD_REG_MODE_AUTO_RETX_MODE | 284 RKCANFD_REG_MODE_COVER_MODE | 285 RKCANFD_REG_MODE_RXSTX_MODE | 286 RKCANFD_REG_MODE_WORK_MODE; 287 288 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 289 priv->reg_mode_default |= RKCANFD_REG_MODE_LBACK_MODE | 290 RKCANFD_REG_MODE_SILENT_MODE | 291 RKCANFD_REG_MODE_SELF_TEST; 292 293 /* mask, i.e. ignore: 294 * - TIMESTAMP_COUNTER_OVERFLOW_INT - timestamp counter overflow interrupt 295 * - TX_ARBIT_FAIL_INT - TX arbitration fail interrupt 296 * - OVERLOAD_INT - CAN bus overload interrupt 297 * - TX_FINISH_INT - Transmit finish interrupt 298 */ 299 priv->reg_int_mask_default = 300 RKCANFD_REG_INT_TIMESTAMP_COUNTER_OVERFLOW_INT | 301 RKCANFD_REG_INT_TX_ARBIT_FAIL_INT | 302 RKCANFD_REG_INT_OVERLOAD_INT | 303 RKCANFD_REG_INT_TX_FINISH_INT; 304 305 /* Do not mask the bus error interrupt if the bus error 306 * reporting is requested. 307 */ 308 if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)) 309 priv->reg_int_mask_default |= RKCANFD_REG_INT_ERROR_INT; 310 311 memset(&priv->bec, 0x0, sizeof(priv->bec)); 312 313 rkcanfd_chip_fifo_setup(priv); 314 rkcanfd_timestamp_init(priv); 315 rkcanfd_timestamp_start(priv); 316 317 rkcanfd_set_bittiming(priv); 318 319 rkcanfd_chip_interrupts_disable(priv); 320 rkcanfd_chip_set_work_mode(priv); 321 322 priv->can.state = CAN_STATE_ERROR_ACTIVE; 323 324 netdev_dbg(priv->ndev, "%s: reg_mode=0x%08x\n", __func__, 325 rkcanfd_read(priv, RKCANFD_REG_MODE)); 326 } 327 328 static void __rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state) 329 { 330 priv->can.state = state; 331 332 rkcanfd_chip_set_reset_mode(priv); 333 rkcanfd_chip_interrupts_disable(priv); 334 } 335 336 static void rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state) 337 { 338 priv->can.state = state; 339 340 rkcanfd_timestamp_stop(priv); 341 __rkcanfd_chip_stop(priv, state); 342 } 343 344 static void rkcanfd_chip_stop_sync(struct rkcanfd_priv *priv, const enum can_state state) 345 { 346 priv->can.state = state; 347 348 rkcanfd_timestamp_stop_sync(priv); 349 __rkcanfd_chip_stop(priv, state); 350 } 351 352 static int rkcanfd_set_mode(struct net_device *ndev, 353 enum can_mode mode) 354 { 355 struct rkcanfd_priv *priv = netdev_priv(ndev); 356 357 switch (mode) { 358 case CAN_MODE_START: 359 rkcanfd_chip_start(priv); 360 rkcanfd_chip_interrupts_enable(priv); 361 netif_wake_queue(ndev); 362 break; 363 364 default: 365 return -EOPNOTSUPP; 366 } 367 368 return 0; 369 } 370 371 static struct sk_buff * 372 rkcanfd_alloc_can_err_skb(struct rkcanfd_priv *priv, 373 struct can_frame **cf, u32 *timestamp) 374 { 375 struct sk_buff *skb; 376 377 *timestamp = rkcanfd_get_timestamp(priv); 378 379 skb = alloc_can_err_skb(priv->ndev, cf); 380 if (skb) 381 rkcanfd_skb_set_timestamp(priv, skb, *timestamp); 382 383 return skb; 384 } 385 386 static const char *rkcanfd_get_error_type_str(unsigned int type) 387 { 388 switch (type) { 389 case RKCANFD_REG_ERROR_CODE_TYPE_BIT: 390 return "Bit"; 391 case RKCANFD_REG_ERROR_CODE_TYPE_STUFF: 392 return "Stuff"; 393 case RKCANFD_REG_ERROR_CODE_TYPE_FORM: 394 return "Form"; 395 case RKCANFD_REG_ERROR_CODE_TYPE_ACK: 396 return "ACK"; 397 case RKCANFD_REG_ERROR_CODE_TYPE_CRC: 398 return "CRC"; 399 } 400 401 return "<unknown>"; 402 } 403 404 #define RKCAN_ERROR_CODE(reg_ec, code) \ 405 ((reg_ec) & RKCANFD_REG_ERROR_CODE_##code ? __stringify(code) " " : "") 406 407 static void 408 rkcanfd_handle_error_int_reg_ec(struct rkcanfd_priv *priv, struct can_frame *cf, 409 const u32 reg_ec) 410 { 411 struct net_device_stats *stats = &priv->ndev->stats; 412 unsigned int type; 413 u32 reg_state, reg_cmd; 414 415 type = FIELD_GET(RKCANFD_REG_ERROR_CODE_TYPE, reg_ec); 416 reg_cmd = rkcanfd_read(priv, RKCANFD_REG_CMD); 417 reg_state = rkcanfd_read(priv, RKCANFD_REG_STATE); 418 419 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", 420 rkcanfd_get_error_type_str(type), 421 reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX ? "RX" : "TX", 422 reg_ec & RKCANFD_REG_ERROR_CODE_PHASE ? "Data" : "Arbitration", 423 RKCAN_ERROR_CODE(reg_ec, TX_OVERLOAD), 424 RKCAN_ERROR_CODE(reg_ec, TX_ERROR), 425 RKCAN_ERROR_CODE(reg_ec, TX_ACK), 426 RKCAN_ERROR_CODE(reg_ec, TX_ACK_EOF), 427 RKCAN_ERROR_CODE(reg_ec, TX_CRC), 428 RKCAN_ERROR_CODE(reg_ec, TX_STUFF_COUNT), 429 RKCAN_ERROR_CODE(reg_ec, TX_DATA), 430 RKCAN_ERROR_CODE(reg_ec, TX_SOF_DLC), 431 RKCAN_ERROR_CODE(reg_ec, TX_IDLE), 432 RKCAN_ERROR_CODE(reg_ec, RX_BUF_INT), 433 RKCAN_ERROR_CODE(reg_ec, RX_SPACE), 434 RKCAN_ERROR_CODE(reg_ec, RX_EOF), 435 RKCAN_ERROR_CODE(reg_ec, RX_ACK_LIM), 436 RKCAN_ERROR_CODE(reg_ec, RX_ACK), 437 RKCAN_ERROR_CODE(reg_ec, RX_CRC_LIM), 438 RKCAN_ERROR_CODE(reg_ec, RX_CRC), 439 RKCAN_ERROR_CODE(reg_ec, RX_STUFF_COUNT), 440 RKCAN_ERROR_CODE(reg_ec, RX_DATA), 441 RKCAN_ERROR_CODE(reg_ec, RX_DLC), 442 RKCAN_ERROR_CODE(reg_ec, RX_BRS_ESI), 443 RKCAN_ERROR_CODE(reg_ec, RX_RES), 444 RKCAN_ERROR_CODE(reg_ec, RX_FDF), 445 RKCAN_ERROR_CODE(reg_ec, RX_ID2_RTR), 446 RKCAN_ERROR_CODE(reg_ec, RX_SOF_IDE), 447 RKCAN_ERROR_CODE(reg_ec, RX_IDLE), 448 reg_ec, reg_cmd, 449 !!(reg_state & RKCANFD_REG_STATE_RX_PERIOD), 450 !!(reg_state & RKCANFD_REG_STATE_TX_PERIOD), 451 !!(reg_state & RKCANFD_REG_STATE_ERROR_WARNING_STATE), 452 !!(reg_state & RKCANFD_REG_STATE_BUS_OFF_STATE)); 453 454 priv->can.can_stats.bus_error++; 455 456 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX) 457 stats->rx_errors++; 458 else 459 stats->tx_errors++; 460 461 if (!cf) 462 return; 463 464 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX) { 465 if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_SOF_IDE) 466 cf->data[3] = CAN_ERR_PROT_LOC_SOF; 467 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ID2_RTR) 468 cf->data[3] = CAN_ERR_PROT_LOC_RTR; 469 /* RKCANFD_REG_ERROR_CODE_RX_FDF */ 470 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_RES) 471 cf->data[3] = CAN_ERR_PROT_LOC_RES0; 472 /* RKCANFD_REG_ERROR_CODE_RX_BRS_ESI */ 473 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_DLC) 474 cf->data[3] = CAN_ERR_PROT_LOC_DLC; 475 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_DATA) 476 cf->data[3] = CAN_ERR_PROT_LOC_DATA; 477 /* RKCANFD_REG_ERROR_CODE_RX_STUFF_COUNT */ 478 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_CRC) 479 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 480 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_CRC_LIM) 481 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 482 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ACK) 483 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 484 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ACK_LIM) 485 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 486 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_EOF) 487 cf->data[3] = CAN_ERR_PROT_LOC_EOF; 488 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_SPACE) 489 cf->data[3] = CAN_ERR_PROT_LOC_EOF; 490 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_BUF_INT) 491 cf->data[3] = CAN_ERR_PROT_LOC_INTERM; 492 } else { 493 cf->data[2] |= CAN_ERR_PROT_TX; 494 495 if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_SOF_DLC) 496 cf->data[3] = CAN_ERR_PROT_LOC_SOF; 497 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_DATA) 498 cf->data[3] = CAN_ERR_PROT_LOC_DATA; 499 /* RKCANFD_REG_ERROR_CODE_TX_STUFF_COUNT */ 500 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_CRC) 501 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 502 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK_EOF) 503 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 504 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK) 505 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 506 /* RKCANFD_REG_ERROR_CODE_TX_ERROR */ 507 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_OVERLOAD) 508 cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 509 } 510 511 switch (reg_ec & RKCANFD_REG_ERROR_CODE_TYPE) { 512 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 513 RKCANFD_REG_ERROR_CODE_TYPE_BIT): 514 515 cf->data[2] |= CAN_ERR_PROT_BIT; 516 break; 517 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 518 RKCANFD_REG_ERROR_CODE_TYPE_STUFF): 519 cf->data[2] |= CAN_ERR_PROT_STUFF; 520 break; 521 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 522 RKCANFD_REG_ERROR_CODE_TYPE_FORM): 523 cf->data[2] |= CAN_ERR_PROT_FORM; 524 break; 525 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 526 RKCANFD_REG_ERROR_CODE_TYPE_ACK): 527 cf->can_id |= CAN_ERR_ACK; 528 break; 529 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 530 RKCANFD_REG_ERROR_CODE_TYPE_CRC): 531 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 532 break; 533 } 534 } 535 536 static int rkcanfd_handle_error_int(struct rkcanfd_priv *priv) 537 { 538 struct net_device_stats *stats = &priv->ndev->stats; 539 struct can_frame *cf = NULL; 540 u32 reg_ec, timestamp; 541 struct sk_buff *skb; 542 int err; 543 544 reg_ec = rkcanfd_read(priv, RKCANFD_REG_ERROR_CODE); 545 546 if (!reg_ec) 547 return 0; 548 549 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) { 550 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp); 551 if (cf) { 552 struct can_berr_counter bec; 553 554 rkcanfd_get_berr_counter_corrected(priv, &bec); 555 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR | CAN_ERR_CNT; 556 cf->data[6] = bec.txerr; 557 cf->data[7] = bec.rxerr; 558 } 559 } 560 561 rkcanfd_handle_error_int_reg_ec(priv, cf, reg_ec); 562 563 if (!cf) 564 return 0; 565 566 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp); 567 if (err) 568 stats->rx_fifo_errors++; 569 570 return 0; 571 } 572 573 static int rkcanfd_handle_state_error_int(struct rkcanfd_priv *priv) 574 { 575 struct net_device_stats *stats = &priv->ndev->stats; 576 enum can_state new_state, rx_state, tx_state; 577 struct net_device *ndev = priv->ndev; 578 struct can_berr_counter bec; 579 struct can_frame *cf = NULL; 580 struct sk_buff *skb; 581 u32 timestamp; 582 int err; 583 584 rkcanfd_get_berr_counter_corrected(priv, &bec); 585 can_state_get_by_berr_counter(ndev, &bec, &tx_state, &rx_state); 586 587 new_state = max(tx_state, rx_state); 588 if (new_state == priv->can.state) 589 return 0; 590 591 /* The skb allocation might fail, but can_change_state() 592 * handles cf == NULL. 593 */ 594 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp); 595 can_change_state(ndev, cf, tx_state, rx_state); 596 597 if (new_state == CAN_STATE_BUS_OFF) { 598 rkcanfd_chip_stop(priv, CAN_STATE_BUS_OFF); 599 can_bus_off(ndev); 600 } 601 602 if (!skb) 603 return 0; 604 605 if (new_state != CAN_STATE_BUS_OFF) { 606 cf->can_id |= CAN_ERR_CNT; 607 cf->data[6] = bec.txerr; 608 cf->data[7] = bec.rxerr; 609 } 610 611 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp); 612 if (err) 613 stats->rx_fifo_errors++; 614 615 return 0; 616 } 617 618 static int 619 rkcanfd_handle_rx_fifo_overflow_int(struct rkcanfd_priv *priv) 620 { 621 struct net_device_stats *stats = &priv->ndev->stats; 622 struct can_berr_counter bec; 623 struct can_frame *cf = NULL; 624 struct sk_buff *skb; 625 u32 timestamp; 626 int err; 627 628 stats->rx_over_errors++; 629 stats->rx_errors++; 630 631 netdev_dbg(priv->ndev, "RX-FIFO overflow\n"); 632 633 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp); 634 if (!skb) 635 return 0; 636 637 rkcanfd_get_berr_counter_corrected(priv, &bec); 638 639 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT; 640 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 641 cf->data[6] = bec.txerr; 642 cf->data[7] = bec.rxerr; 643 644 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp); 645 if (err) 646 stats->rx_fifo_errors++; 647 648 return 0; 649 } 650 651 #define rkcanfd_handle(priv, irq, ...) \ 652 ({ \ 653 struct rkcanfd_priv *_priv = (priv); \ 654 int err; \ 655 \ 656 err = rkcanfd_handle_##irq(_priv, ## __VA_ARGS__); \ 657 if (err) \ 658 netdev_err(_priv->ndev, \ 659 "IRQ handler rkcanfd_handle_%s() returned error: %pe\n", \ 660 __stringify(irq), ERR_PTR(err)); \ 661 err; \ 662 }) 663 664 static irqreturn_t rkcanfd_irq(int irq, void *dev_id) 665 { 666 struct rkcanfd_priv *priv = dev_id; 667 u32 reg_int_unmasked, reg_int; 668 669 reg_int_unmasked = rkcanfd_read(priv, RKCANFD_REG_INT); 670 reg_int = reg_int_unmasked & ~priv->reg_int_mask_default; 671 672 if (!reg_int) 673 return IRQ_NONE; 674 675 /* First ACK then handle, to avoid lost-IRQ race condition on 676 * fast re-occurring interrupts. 677 */ 678 rkcanfd_write(priv, RKCANFD_REG_INT, reg_int); 679 680 if (reg_int & RKCANFD_REG_INT_RX_FINISH_INT) 681 rkcanfd_handle(priv, rx_int); 682 683 if (reg_int & RKCANFD_REG_INT_ERROR_INT) 684 rkcanfd_handle(priv, error_int); 685 686 if (reg_int & (RKCANFD_REG_INT_BUS_OFF_INT | 687 RKCANFD_REG_INT_PASSIVE_ERROR_INT | 688 RKCANFD_REG_INT_ERROR_WARNING_INT) || 689 priv->can.state > CAN_STATE_ERROR_ACTIVE) 690 rkcanfd_handle(priv, state_error_int); 691 692 if (reg_int & RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT) 693 rkcanfd_handle(priv, rx_fifo_overflow_int); 694 695 if (reg_int & ~(RKCANFD_REG_INT_ALL_ERROR | 696 RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT | 697 RKCANFD_REG_INT_RX_FINISH_INT)) 698 netdev_err(priv->ndev, "%s: int=0x%08x\n", __func__, reg_int); 699 700 if (reg_int & RKCANFD_REG_INT_WAKEUP_INT) 701 netdev_info(priv->ndev, "%s: WAKEUP_INT\n", __func__); 702 703 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_FULL_INT) 704 netdev_info(priv->ndev, "%s: TXE_FIFO_FULL_INT\n", __func__); 705 706 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_OV_INT) 707 netdev_info(priv->ndev, "%s: TXE_FIFO_OV_INT\n", __func__); 708 709 if (reg_int & RKCANFD_REG_INT_BUS_OFF_RECOVERY_INT) 710 netdev_info(priv->ndev, "%s: BUS_OFF_RECOVERY_INT\n", __func__); 711 712 if (reg_int & RKCANFD_REG_INT_RX_FIFO_FULL_INT) 713 netdev_info(priv->ndev, "%s: RX_FIFO_FULL_INT\n", __func__); 714 715 if (reg_int & RKCANFD_REG_INT_OVERLOAD_INT) 716 netdev_info(priv->ndev, "%s: OVERLOAD_INT\n", __func__); 717 718 can_rx_offload_irq_finish(&priv->offload); 719 720 return IRQ_HANDLED; 721 } 722 723 static int rkcanfd_open(struct net_device *ndev) 724 { 725 struct rkcanfd_priv *priv = netdev_priv(ndev); 726 int err; 727 728 err = open_candev(ndev); 729 if (err) 730 return err; 731 732 err = pm_runtime_resume_and_get(ndev->dev.parent); 733 if (err) 734 goto out_close_candev; 735 736 rkcanfd_chip_start(priv); 737 can_rx_offload_enable(&priv->offload); 738 739 err = request_irq(ndev->irq, rkcanfd_irq, IRQF_SHARED, ndev->name, priv); 740 if (err) 741 goto out_rkcanfd_chip_stop; 742 743 rkcanfd_chip_interrupts_enable(priv); 744 745 netif_start_queue(ndev); 746 747 return 0; 748 749 out_rkcanfd_chip_stop: 750 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED); 751 pm_runtime_put(ndev->dev.parent); 752 out_close_candev: 753 close_candev(ndev); 754 return err; 755 } 756 757 static int rkcanfd_stop(struct net_device *ndev) 758 { 759 struct rkcanfd_priv *priv = netdev_priv(ndev); 760 761 netif_stop_queue(ndev); 762 763 rkcanfd_chip_interrupts_disable(priv); 764 free_irq(ndev->irq, priv); 765 can_rx_offload_disable(&priv->offload); 766 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED); 767 close_candev(ndev); 768 769 pm_runtime_put(ndev->dev.parent); 770 771 return 0; 772 } 773 774 static const struct net_device_ops rkcanfd_netdev_ops = { 775 .ndo_open = rkcanfd_open, 776 .ndo_stop = rkcanfd_stop, 777 .ndo_start_xmit = rkcanfd_start_xmit, 778 }; 779 780 static int __maybe_unused rkcanfd_runtime_suspend(struct device *dev) 781 { 782 struct rkcanfd_priv *priv = dev_get_drvdata(dev); 783 784 clk_bulk_disable_unprepare(priv->clks_num, priv->clks); 785 786 return 0; 787 } 788 789 static int __maybe_unused rkcanfd_runtime_resume(struct device *dev) 790 { 791 struct rkcanfd_priv *priv = dev_get_drvdata(dev); 792 793 return clk_bulk_prepare_enable(priv->clks_num, priv->clks); 794 } 795 796 static void rkcanfd_register_done(const struct rkcanfd_priv *priv) 797 { 798 u32 dev_id; 799 800 dev_id = rkcanfd_read(priv, RKCANFD_REG_RTL_VERSION); 801 802 netdev_info(priv->ndev, 803 "Rockchip-CANFD %s rev%lu.%lu (errata 0x%04x) found\n", 804 rkcanfd_get_model_str(priv), 805 FIELD_GET(RKCANFD_REG_RTL_VERSION_MAJOR, dev_id), 806 FIELD_GET(RKCANFD_REG_RTL_VERSION_MINOR, dev_id), 807 priv->devtype_data.quirks); 808 809 if (priv->devtype_data.quirks & RKCANFD_QUIRK_RK3568_ERRATUM_5 && 810 priv->can.clock.freq < RKCANFD_ERRATUM_5_SYSCLOCK_HZ_MIN) 811 netdev_info(priv->ndev, 812 "Erratum 5: CAN clock frequency (%luMHz) lower than known good (%luMHz), expect degraded performance\n", 813 priv->can.clock.freq / MEGA, 814 RKCANFD_ERRATUM_5_SYSCLOCK_HZ_MIN / MEGA); 815 } 816 817 static int rkcanfd_register(struct rkcanfd_priv *priv) 818 { 819 struct net_device *ndev = priv->ndev; 820 int err; 821 822 pm_runtime_enable(ndev->dev.parent); 823 824 err = pm_runtime_resume_and_get(ndev->dev.parent); 825 if (err) 826 goto out_pm_runtime_disable; 827 828 rkcanfd_ethtool_init(priv); 829 830 err = register_candev(ndev); 831 if (err) 832 goto out_pm_runtime_put_sync; 833 834 rkcanfd_register_done(priv); 835 836 pm_runtime_put(ndev->dev.parent); 837 838 return 0; 839 840 out_pm_runtime_put_sync: 841 pm_runtime_put_sync(ndev->dev.parent); 842 out_pm_runtime_disable: 843 pm_runtime_disable(ndev->dev.parent); 844 845 return err; 846 } 847 848 static inline void rkcanfd_unregister(struct rkcanfd_priv *priv) 849 { 850 struct net_device *ndev = priv->ndev; 851 852 unregister_candev(ndev); 853 pm_runtime_disable(ndev->dev.parent); 854 } 855 856 static const struct of_device_id rkcanfd_of_match[] = { 857 { 858 .compatible = "rockchip,rk3568v2-canfd", 859 .data = &rkcanfd_devtype_data_rk3568v2, 860 }, { 861 .compatible = "rockchip,rk3568v3-canfd", 862 .data = &rkcanfd_devtype_data_rk3568v3, 863 }, { 864 .compatible = "rockchip,rk3588-canfd", 865 .data = &rkcanfd_devtype_data_rk3588, 866 }, { 867 /* sentinel */ 868 }, 869 }; 870 MODULE_DEVICE_TABLE(of, rkcanfd_of_match); 871 872 static int rkcanfd_probe(struct platform_device *pdev) 873 { 874 struct rkcanfd_priv *priv; 875 struct net_device *ndev; 876 const void *match; 877 int err; 878 879 ndev = alloc_candev(sizeof(struct rkcanfd_priv), RKCANFD_TXFIFO_DEPTH); 880 if (!ndev) 881 return -ENOMEM; 882 883 priv = netdev_priv(ndev); 884 885 ndev->irq = platform_get_irq(pdev, 0); 886 if (ndev->irq < 0) { 887 err = ndev->irq; 888 goto out_free_candev; 889 } 890 891 priv->clks_num = devm_clk_bulk_get_all(&pdev->dev, &priv->clks); 892 if (priv->clks_num < 0) { 893 err = priv->clks_num; 894 goto out_free_candev; 895 } 896 897 priv->regs = devm_platform_ioremap_resource(pdev, 0); 898 if (IS_ERR(priv->regs)) { 899 err = PTR_ERR(priv->regs); 900 goto out_free_candev; 901 } 902 903 priv->reset = devm_reset_control_array_get_exclusive(&pdev->dev); 904 if (IS_ERR(priv->reset)) { 905 err = dev_err_probe(&pdev->dev, PTR_ERR(priv->reset), 906 "Failed to get reset line\n"); 907 goto out_free_candev; 908 } 909 910 SET_NETDEV_DEV(ndev, &pdev->dev); 911 912 ndev->netdev_ops = &rkcanfd_netdev_ops; 913 ndev->flags |= IFF_ECHO; 914 915 platform_set_drvdata(pdev, priv); 916 priv->can.clock.freq = clk_get_rate(priv->clks[0].clk); 917 priv->can.bittiming_const = &rkcanfd_bittiming_const; 918 priv->can.fd.data_bittiming_const = &rkcanfd_data_bittiming_const; 919 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 920 CAN_CTRLMODE_BERR_REPORTING; 921 priv->can.do_set_mode = rkcanfd_set_mode; 922 priv->can.do_get_berr_counter = rkcanfd_get_berr_counter; 923 priv->ndev = ndev; 924 925 match = device_get_match_data(&pdev->dev); 926 if (match) { 927 priv->devtype_data = *(struct rkcanfd_devtype_data *)match; 928 if (!(priv->devtype_data.quirks & RKCANFD_QUIRK_CANFD_BROKEN)) 929 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD; 930 } 931 932 err = can_rx_offload_add_manual(ndev, &priv->offload, 933 RKCANFD_NAPI_WEIGHT); 934 if (err) 935 goto out_free_candev; 936 937 err = rkcanfd_register(priv); 938 if (err) 939 goto out_can_rx_offload_del; 940 941 return 0; 942 943 out_can_rx_offload_del: 944 can_rx_offload_del(&priv->offload); 945 out_free_candev: 946 free_candev(ndev); 947 948 return err; 949 } 950 951 static void rkcanfd_remove(struct platform_device *pdev) 952 { 953 struct rkcanfd_priv *priv = platform_get_drvdata(pdev); 954 struct net_device *ndev = priv->ndev; 955 956 rkcanfd_unregister(priv); 957 can_rx_offload_del(&priv->offload); 958 free_candev(ndev); 959 } 960 961 static const struct dev_pm_ops rkcanfd_pm_ops = { 962 SET_RUNTIME_PM_OPS(rkcanfd_runtime_suspend, 963 rkcanfd_runtime_resume, NULL) 964 }; 965 966 static struct platform_driver rkcanfd_driver = { 967 .driver = { 968 .name = DEVICE_NAME, 969 .pm = &rkcanfd_pm_ops, 970 .of_match_table = rkcanfd_of_match, 971 }, 972 .probe = rkcanfd_probe, 973 .remove = rkcanfd_remove, 974 }; 975 module_platform_driver(rkcanfd_driver); 976 977 MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>"); 978 MODULE_DESCRIPTION("Rockchip CAN-FD Driver"); 979 MODULE_LICENSE("GPL"); 980