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 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 65 static inline const char * 66 rkcanfd_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 (both 78 * for the arbitration and data bit timing) to take the "2 x" into 79 * account. 80 */ 81 static 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 93 static 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 105 static 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 114 static 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 119 static 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 162 static void rkcanfd_get_berr_counter_raw(struct rkcanfd_priv *priv, 163 struct can_berr_counter *bec) 164 { 165 bec->rxerr = rkcanfd_read(priv, RKCANFD_REG_RXERRORCNT); 166 bec->txerr = rkcanfd_read(priv, RKCANFD_REG_TXERRORCNT); 167 } 168 169 static int rkcanfd_get_berr_counter(const struct net_device *ndev, 170 struct can_berr_counter *bec) 171 { 172 struct rkcanfd_priv *priv = netdev_priv(ndev); 173 int err; 174 175 err = pm_runtime_resume_and_get(ndev->dev.parent); 176 if (err) 177 return err; 178 179 rkcanfd_get_berr_counter_raw(priv, bec); 180 181 pm_runtime_put(ndev->dev.parent); 182 183 return 0; 184 } 185 186 static void rkcanfd_chip_interrupts_enable(const struct rkcanfd_priv *priv) 187 { 188 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, priv->reg_int_mask_default); 189 190 netdev_dbg(priv->ndev, "%s: reg_int_mask=0x%08x\n", __func__, 191 rkcanfd_read(priv, RKCANFD_REG_INT_MASK)); 192 } 193 194 static void rkcanfd_chip_interrupts_disable(const struct rkcanfd_priv *priv) 195 { 196 rkcanfd_write(priv, RKCANFD_REG_INT_MASK, RKCANFD_REG_INT_ALL); 197 } 198 199 static void rkcanfd_chip_fifo_setup(struct rkcanfd_priv *priv) 200 { 201 u32 reg; 202 203 /* TXE FIFO */ 204 reg = rkcanfd_read(priv, RKCANFD_REG_RX_FIFO_CTRL); 205 reg |= RKCANFD_REG_RX_FIFO_CTRL_RX_FIFO_ENABLE; 206 rkcanfd_write(priv, RKCANFD_REG_RX_FIFO_CTRL, reg); 207 208 /* RX FIFO */ 209 reg = rkcanfd_read(priv, RKCANFD_REG_RX_FIFO_CTRL); 210 reg |= RKCANFD_REG_RX_FIFO_CTRL_RX_FIFO_ENABLE; 211 rkcanfd_write(priv, RKCANFD_REG_RX_FIFO_CTRL, reg); 212 213 WRITE_ONCE(priv->tx_head, 0); 214 WRITE_ONCE(priv->tx_tail, 0); 215 netdev_reset_queue(priv->ndev); 216 } 217 218 static void rkcanfd_chip_start(struct rkcanfd_priv *priv) 219 { 220 u32 reg; 221 222 rkcanfd_chip_set_reset_mode(priv); 223 224 /* Receiving Filter: accept all */ 225 rkcanfd_write(priv, RKCANFD_REG_IDCODE, 0x0); 226 rkcanfd_write(priv, RKCANFD_REG_IDMASK, RKCANFD_REG_IDCODE_EXTENDED_FRAME_ID); 227 228 /* enable: 229 * - CAN_FD: enable CAN-FD 230 * - AUTO_RETX_MODE: auto retransmission on TX error 231 * - COVER_MODE: RX-FIFO overwrite mode, do not send OVERLOAD frames 232 * - WORK_MODE: transition from reset to working mode 233 */ 234 reg = rkcanfd_read(priv, RKCANFD_REG_MODE); 235 priv->reg_mode_default = reg | 236 RKCANFD_REG_MODE_CAN_FD_MODE_ENABLE | 237 RKCANFD_REG_MODE_AUTO_RETX_MODE | 238 RKCANFD_REG_MODE_COVER_MODE | 239 RKCANFD_REG_MODE_WORK_MODE; 240 241 /* mask, i.e. ignore: 242 * - TIMESTAMP_COUNTER_OVERFLOW_INT - timestamp counter overflow interrupt 243 * - TX_ARBIT_FAIL_INT - TX arbitration fail interrupt 244 * - OVERLOAD_INT - CAN bus overload interrupt 245 */ 246 priv->reg_int_mask_default = 247 RKCANFD_REG_INT_TIMESTAMP_COUNTER_OVERFLOW_INT | 248 RKCANFD_REG_INT_TX_ARBIT_FAIL_INT | 249 RKCANFD_REG_INT_OVERLOAD_INT; 250 251 rkcanfd_chip_fifo_setup(priv); 252 rkcanfd_timestamp_init(priv); 253 rkcanfd_set_bittiming(priv); 254 255 rkcanfd_chip_interrupts_disable(priv); 256 rkcanfd_chip_set_work_mode(priv); 257 258 priv->can.state = CAN_STATE_ERROR_ACTIVE; 259 260 netdev_dbg(priv->ndev, "%s: reg_mode=0x%08x\n", __func__, 261 rkcanfd_read(priv, RKCANFD_REG_MODE)); 262 } 263 264 static void __rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state) 265 { 266 priv->can.state = state; 267 268 rkcanfd_chip_set_reset_mode(priv); 269 rkcanfd_chip_interrupts_disable(priv); 270 } 271 272 static void rkcanfd_chip_stop(struct rkcanfd_priv *priv, const enum can_state state) 273 { 274 priv->can.state = state; 275 276 __rkcanfd_chip_stop(priv, state); 277 } 278 279 static void rkcanfd_chip_stop_sync(struct rkcanfd_priv *priv, const enum can_state state) 280 { 281 priv->can.state = state; 282 283 __rkcanfd_chip_stop(priv, state); 284 } 285 286 static int rkcanfd_set_mode(struct net_device *ndev, 287 enum can_mode mode) 288 { 289 struct rkcanfd_priv *priv = netdev_priv(ndev); 290 291 switch (mode) { 292 case CAN_MODE_START: 293 rkcanfd_chip_start(priv); 294 rkcanfd_chip_interrupts_enable(priv); 295 netif_wake_queue(ndev); 296 break; 297 298 default: 299 return -EOPNOTSUPP; 300 } 301 302 return 0; 303 } 304 305 static struct sk_buff * 306 rkcanfd_alloc_can_err_skb(struct rkcanfd_priv *priv, 307 struct can_frame **cf, u32 *timestamp) 308 { 309 struct sk_buff *skb; 310 311 *timestamp = rkcanfd_get_timestamp(priv); 312 313 skb = alloc_can_err_skb(priv->ndev, cf); 314 315 return skb; 316 } 317 318 static const char *rkcanfd_get_error_type_str(unsigned int type) 319 { 320 switch (type) { 321 case RKCANFD_REG_ERROR_CODE_TYPE_BIT: 322 return "Bit"; 323 case RKCANFD_REG_ERROR_CODE_TYPE_STUFF: 324 return "Stuff"; 325 case RKCANFD_REG_ERROR_CODE_TYPE_FORM: 326 return "Form"; 327 case RKCANFD_REG_ERROR_CODE_TYPE_ACK: 328 return "ACK"; 329 case RKCANFD_REG_ERROR_CODE_TYPE_CRC: 330 return "CRC"; 331 } 332 333 return "<unknown>"; 334 } 335 336 #define RKCAN_ERROR_CODE(reg_ec, code) \ 337 ((reg_ec) & RKCANFD_REG_ERROR_CODE_##code ? __stringify(code) " " : "") 338 339 static void 340 rkcanfd_handle_error_int_reg_ec(struct rkcanfd_priv *priv, struct can_frame *cf, 341 const u32 reg_ec) 342 { 343 struct net_device_stats *stats = &priv->ndev->stats; 344 unsigned int type; 345 u32 reg_state, reg_cmd; 346 347 type = FIELD_GET(RKCANFD_REG_ERROR_CODE_TYPE, reg_ec); 348 reg_cmd = rkcanfd_read(priv, RKCANFD_REG_CMD); 349 reg_state = rkcanfd_read(priv, RKCANFD_REG_STATE); 350 351 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", 352 rkcanfd_get_error_type_str(type), 353 reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX ? "RX" : "TX", 354 reg_ec & RKCANFD_REG_ERROR_CODE_PHASE ? "Data" : "Arbitration", 355 RKCAN_ERROR_CODE(reg_ec, TX_OVERLOAD), 356 RKCAN_ERROR_CODE(reg_ec, TX_ERROR), 357 RKCAN_ERROR_CODE(reg_ec, TX_ACK), 358 RKCAN_ERROR_CODE(reg_ec, TX_ACK_EOF), 359 RKCAN_ERROR_CODE(reg_ec, TX_CRC), 360 RKCAN_ERROR_CODE(reg_ec, TX_STUFF_COUNT), 361 RKCAN_ERROR_CODE(reg_ec, TX_DATA), 362 RKCAN_ERROR_CODE(reg_ec, TX_SOF_DLC), 363 RKCAN_ERROR_CODE(reg_ec, TX_IDLE), 364 RKCAN_ERROR_CODE(reg_ec, RX_BUF_INT), 365 RKCAN_ERROR_CODE(reg_ec, RX_SPACE), 366 RKCAN_ERROR_CODE(reg_ec, RX_EOF), 367 RKCAN_ERROR_CODE(reg_ec, RX_ACK_LIM), 368 RKCAN_ERROR_CODE(reg_ec, RX_ACK), 369 RKCAN_ERROR_CODE(reg_ec, RX_CRC_LIM), 370 RKCAN_ERROR_CODE(reg_ec, RX_CRC), 371 RKCAN_ERROR_CODE(reg_ec, RX_STUFF_COUNT), 372 RKCAN_ERROR_CODE(reg_ec, RX_DATA), 373 RKCAN_ERROR_CODE(reg_ec, RX_DLC), 374 RKCAN_ERROR_CODE(reg_ec, RX_BRS_ESI), 375 RKCAN_ERROR_CODE(reg_ec, RX_RES), 376 RKCAN_ERROR_CODE(reg_ec, RX_FDF), 377 RKCAN_ERROR_CODE(reg_ec, RX_ID2_RTR), 378 RKCAN_ERROR_CODE(reg_ec, RX_SOF_IDE), 379 RKCAN_ERROR_CODE(reg_ec, RX_IDLE), 380 reg_ec, reg_cmd, 381 !!(reg_state & RKCANFD_REG_STATE_RX_PERIOD), 382 !!(reg_state & RKCANFD_REG_STATE_TX_PERIOD), 383 !!(reg_state & RKCANFD_REG_STATE_ERROR_WARNING_STATE), 384 !!(reg_state & RKCANFD_REG_STATE_BUS_OFF_STATE)); 385 386 priv->can.can_stats.bus_error++; 387 388 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX) 389 stats->rx_errors++; 390 else 391 stats->tx_errors++; 392 393 if (!cf) 394 return; 395 396 if (reg_ec & RKCANFD_REG_ERROR_CODE_DIRECTION_RX) { 397 if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_SOF_IDE) 398 cf->data[3] = CAN_ERR_PROT_LOC_SOF; 399 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ID2_RTR) 400 cf->data[3] = CAN_ERR_PROT_LOC_RTR; 401 /* RKCANFD_REG_ERROR_CODE_RX_FDF */ 402 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_RES) 403 cf->data[3] = CAN_ERR_PROT_LOC_RES0; 404 /* RKCANFD_REG_ERROR_CODE_RX_BRS_ESI */ 405 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_DLC) 406 cf->data[3] = CAN_ERR_PROT_LOC_DLC; 407 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_DATA) 408 cf->data[3] = CAN_ERR_PROT_LOC_DATA; 409 /* RKCANFD_REG_ERROR_CODE_RX_STUFF_COUNT */ 410 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_CRC) 411 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 412 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_CRC_LIM) 413 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 414 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ACK) 415 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 416 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_ACK_LIM) 417 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 418 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_EOF) 419 cf->data[3] = CAN_ERR_PROT_LOC_EOF; 420 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_SPACE) 421 cf->data[3] = CAN_ERR_PROT_LOC_EOF; 422 else if (reg_ec & RKCANFD_REG_ERROR_CODE_RX_BUF_INT) 423 cf->data[3] = CAN_ERR_PROT_LOC_INTERM; 424 } else { 425 cf->data[2] |= CAN_ERR_PROT_TX; 426 427 if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_SOF_DLC) 428 cf->data[3] = CAN_ERR_PROT_LOC_SOF; 429 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_DATA) 430 cf->data[3] = CAN_ERR_PROT_LOC_DATA; 431 /* RKCANFD_REG_ERROR_CODE_TX_STUFF_COUNT */ 432 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_CRC) 433 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 434 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK_EOF) 435 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 436 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK) 437 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 438 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_ACK_EOF) 439 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 440 /* RKCANFD_REG_ERROR_CODE_TX_ERROR */ 441 else if (reg_ec & RKCANFD_REG_ERROR_CODE_TX_OVERLOAD) 442 cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 443 } 444 445 switch (reg_ec & RKCANFD_REG_ERROR_CODE_TYPE) { 446 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 447 RKCANFD_REG_ERROR_CODE_TYPE_BIT): 448 449 cf->data[2] |= CAN_ERR_PROT_BIT; 450 break; 451 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 452 RKCANFD_REG_ERROR_CODE_TYPE_STUFF): 453 cf->data[2] |= CAN_ERR_PROT_STUFF; 454 break; 455 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 456 RKCANFD_REG_ERROR_CODE_TYPE_FORM): 457 cf->data[2] |= CAN_ERR_PROT_FORM; 458 break; 459 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 460 RKCANFD_REG_ERROR_CODE_TYPE_ACK): 461 cf->can_id |= CAN_ERR_ACK; 462 break; 463 case FIELD_PREP_CONST(RKCANFD_REG_ERROR_CODE_TYPE, 464 RKCANFD_REG_ERROR_CODE_TYPE_CRC): 465 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 466 break; 467 } 468 } 469 470 static int rkcanfd_handle_error_int(struct rkcanfd_priv *priv) 471 { 472 struct net_device_stats *stats = &priv->ndev->stats; 473 struct can_frame *cf = NULL; 474 u32 reg_ec, timestamp; 475 struct sk_buff *skb; 476 int err; 477 478 reg_ec = rkcanfd_read(priv, RKCANFD_REG_ERROR_CODE); 479 480 if (!reg_ec) 481 return 0; 482 483 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp); 484 if (cf) { 485 struct can_berr_counter bec; 486 487 rkcanfd_get_berr_counter_raw(priv, &bec); 488 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR | CAN_ERR_CNT; 489 cf->data[6] = bec.txerr; 490 cf->data[7] = bec.rxerr; 491 } 492 493 rkcanfd_handle_error_int_reg_ec(priv, cf, reg_ec); 494 495 if (!cf) 496 return 0; 497 498 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp); 499 if (err) 500 stats->rx_fifo_errors++; 501 502 return 0; 503 } 504 505 static int rkcanfd_handle_state_error_int(struct rkcanfd_priv *priv) 506 { 507 struct net_device_stats *stats = &priv->ndev->stats; 508 enum can_state new_state, rx_state, tx_state; 509 struct net_device *ndev = priv->ndev; 510 struct can_berr_counter bec; 511 struct can_frame *cf = NULL; 512 struct sk_buff *skb; 513 u32 timestamp; 514 int err; 515 516 rkcanfd_get_berr_counter_raw(priv, &bec); 517 can_state_get_by_berr_counter(ndev, &bec, &tx_state, &rx_state); 518 519 new_state = max(tx_state, rx_state); 520 if (new_state == priv->can.state) 521 return 0; 522 523 /* The skb allocation might fail, but can_change_state() 524 * handles cf == NULL. 525 */ 526 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp); 527 can_change_state(ndev, cf, tx_state, rx_state); 528 529 if (new_state == CAN_STATE_BUS_OFF) { 530 rkcanfd_chip_stop(priv, CAN_STATE_BUS_OFF); 531 can_bus_off(ndev); 532 } 533 534 if (!skb) 535 return 0; 536 537 if (new_state != CAN_STATE_BUS_OFF) { 538 cf->can_id |= CAN_ERR_CNT; 539 cf->data[6] = bec.txerr; 540 cf->data[7] = bec.rxerr; 541 } 542 543 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp); 544 if (err) 545 stats->rx_fifo_errors++; 546 547 return 0; 548 } 549 550 static int 551 rkcanfd_handle_rx_fifo_overflow_int(struct rkcanfd_priv *priv) 552 { 553 struct net_device_stats *stats = &priv->ndev->stats; 554 struct can_berr_counter bec; 555 struct can_frame *cf = NULL; 556 struct sk_buff *skb; 557 u32 timestamp; 558 int err; 559 560 stats->rx_over_errors++; 561 stats->rx_errors++; 562 563 netdev_dbg(priv->ndev, "RX-FIFO overflow\n"); 564 565 skb = rkcanfd_alloc_can_err_skb(priv, &cf, ×tamp); 566 if (skb) 567 return 0; 568 569 rkcanfd_get_berr_counter_raw(priv, &bec); 570 571 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT; 572 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 573 cf->data[6] = bec.txerr; 574 cf->data[7] = bec.rxerr; 575 576 err = can_rx_offload_queue_timestamp(&priv->offload, skb, timestamp); 577 if (err) 578 stats->rx_fifo_errors++; 579 580 return 0; 581 } 582 583 #define rkcanfd_handle(priv, irq, ...) \ 584 ({ \ 585 struct rkcanfd_priv *_priv = (priv); \ 586 int err; \ 587 \ 588 err = rkcanfd_handle_##irq(_priv, ## __VA_ARGS__); \ 589 if (err) \ 590 netdev_err(_priv->ndev, \ 591 "IRQ handler rkcanfd_handle_%s() returned error: %pe\n", \ 592 __stringify(irq), ERR_PTR(err)); \ 593 err; \ 594 }) 595 596 static irqreturn_t rkcanfd_irq(int irq, void *dev_id) 597 { 598 struct rkcanfd_priv *priv = dev_id; 599 u32 reg_int_unmasked, reg_int; 600 601 reg_int_unmasked = rkcanfd_read(priv, RKCANFD_REG_INT); 602 reg_int = reg_int_unmasked & ~priv->reg_int_mask_default; 603 604 if (!reg_int) 605 return IRQ_NONE; 606 607 /* First ACK then handle, to avoid lost-IRQ race condition on 608 * fast re-occurring interrupts. 609 */ 610 rkcanfd_write(priv, RKCANFD_REG_INT, reg_int); 611 612 if (reg_int & RKCANFD_REG_INT_RX_FINISH_INT) 613 rkcanfd_handle(priv, rx_int); 614 615 if (reg_int & RKCANFD_REG_INT_ERROR_INT) 616 rkcanfd_handle(priv, error_int); 617 618 if (reg_int & (RKCANFD_REG_INT_BUS_OFF_INT | 619 RKCANFD_REG_INT_PASSIVE_ERROR_INT | 620 RKCANFD_REG_INT_ERROR_WARNING_INT) || 621 priv->can.state > CAN_STATE_ERROR_ACTIVE) 622 rkcanfd_handle(priv, state_error_int); 623 624 if (reg_int & RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT) 625 rkcanfd_handle(priv, rx_fifo_overflow_int); 626 627 if (reg_int & ~(RKCANFD_REG_INT_ALL_ERROR | 628 RKCANFD_REG_INT_RX_FIFO_OVERFLOW_INT | 629 RKCANFD_REG_INT_RX_FINISH_INT)) 630 netdev_err(priv->ndev, "%s: int=0x%08x\n", __func__, reg_int); 631 632 if (reg_int & RKCANFD_REG_INT_WAKEUP_INT) 633 netdev_info(priv->ndev, "%s: WAKEUP_INT\n", __func__); 634 635 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_FULL_INT) 636 netdev_info(priv->ndev, "%s: TXE_FIFO_FULL_INT\n", __func__); 637 638 if (reg_int & RKCANFD_REG_INT_TXE_FIFO_OV_INT) 639 netdev_info(priv->ndev, "%s: TXE_FIFO_OV_INT\n", __func__); 640 641 if (reg_int & RKCANFD_REG_INT_BUS_OFF_RECOVERY_INT) 642 netdev_info(priv->ndev, "%s: BUS_OFF_RECOVERY_INT\n", __func__); 643 644 if (reg_int & RKCANFD_REG_INT_RX_FIFO_FULL_INT) 645 netdev_info(priv->ndev, "%s: RX_FIFO_FULL_INT\n", __func__); 646 647 if (reg_int & RKCANFD_REG_INT_OVERLOAD_INT) 648 netdev_info(priv->ndev, "%s: OVERLOAD_INT\n", __func__); 649 650 can_rx_offload_irq_finish(&priv->offload); 651 652 return IRQ_HANDLED; 653 } 654 655 static int rkcanfd_open(struct net_device *ndev) 656 { 657 struct rkcanfd_priv *priv = netdev_priv(ndev); 658 int err; 659 660 err = open_candev(ndev); 661 if (err) 662 return err; 663 664 err = pm_runtime_resume_and_get(ndev->dev.parent); 665 if (err) 666 goto out_close_candev; 667 668 rkcanfd_chip_start(priv); 669 can_rx_offload_enable(&priv->offload); 670 671 err = request_irq(ndev->irq, rkcanfd_irq, IRQF_SHARED, ndev->name, priv); 672 if (err) 673 goto out_rkcanfd_chip_stop; 674 675 rkcanfd_chip_interrupts_enable(priv); 676 677 netif_start_queue(ndev); 678 679 return 0; 680 681 out_rkcanfd_chip_stop: 682 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED); 683 pm_runtime_put(ndev->dev.parent); 684 out_close_candev: 685 close_candev(ndev); 686 return err; 687 } 688 689 static int rkcanfd_stop(struct net_device *ndev) 690 { 691 struct rkcanfd_priv *priv = netdev_priv(ndev); 692 693 netif_stop_queue(ndev); 694 695 rkcanfd_chip_interrupts_disable(priv); 696 free_irq(ndev->irq, priv); 697 can_rx_offload_disable(&priv->offload); 698 rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED); 699 close_candev(ndev); 700 701 pm_runtime_put(ndev->dev.parent); 702 703 return 0; 704 } 705 706 static const struct net_device_ops rkcanfd_netdev_ops = { 707 .ndo_open = rkcanfd_open, 708 .ndo_stop = rkcanfd_stop, 709 .ndo_start_xmit = rkcanfd_start_xmit, 710 .ndo_change_mtu = can_change_mtu, 711 }; 712 713 static int __maybe_unused rkcanfd_runtime_suspend(struct device *dev) 714 { 715 struct rkcanfd_priv *priv = dev_get_drvdata(dev); 716 717 clk_bulk_disable_unprepare(priv->clks_num, priv->clks); 718 719 return 0; 720 } 721 722 static int __maybe_unused rkcanfd_runtime_resume(struct device *dev) 723 { 724 struct rkcanfd_priv *priv = dev_get_drvdata(dev); 725 726 return clk_bulk_prepare_enable(priv->clks_num, priv->clks); 727 } 728 729 static void rkcanfd_register_done(const struct rkcanfd_priv *priv) 730 { 731 u32 dev_id; 732 733 dev_id = rkcanfd_read(priv, RKCANFD_REG_RTL_VERSION); 734 735 netdev_info(priv->ndev, 736 "Rockchip-CANFD %s rev%lu.%lu (errata 0x%04x) found\n", 737 rkcanfd_get_model_str(priv), 738 FIELD_GET(RKCANFD_REG_RTL_VERSION_MAJOR, dev_id), 739 FIELD_GET(RKCANFD_REG_RTL_VERSION_MINOR, dev_id), 740 priv->devtype_data.quirks); 741 742 if (priv->devtype_data.quirks & RKCANFD_QUIRK_RK3568_ERRATUM_5 && 743 priv->can.clock.freq < RKCANFD_ERRATUM_5_SYSCLOCK_HZ_MIN) 744 netdev_info(priv->ndev, 745 "Erratum 5: CAN clock frequency (%luMHz) lower than known good (%luMHz), expect degraded performance\n", 746 priv->can.clock.freq / MEGA, 747 RKCANFD_ERRATUM_5_SYSCLOCK_HZ_MIN / MEGA); 748 } 749 750 static int rkcanfd_register(struct rkcanfd_priv *priv) 751 { 752 struct net_device *ndev = priv->ndev; 753 int err; 754 755 pm_runtime_enable(ndev->dev.parent); 756 757 err = pm_runtime_resume_and_get(ndev->dev.parent); 758 if (err) 759 goto out_pm_runtime_disable; 760 761 err = register_candev(ndev); 762 if (err) 763 goto out_pm_runtime_put_sync; 764 765 rkcanfd_register_done(priv); 766 767 pm_runtime_put(ndev->dev.parent); 768 769 return 0; 770 771 out_pm_runtime_put_sync: 772 pm_runtime_put_sync(ndev->dev.parent); 773 out_pm_runtime_disable: 774 pm_runtime_disable(ndev->dev.parent); 775 776 return err; 777 } 778 779 static inline void rkcanfd_unregister(struct rkcanfd_priv *priv) 780 { 781 struct net_device *ndev = priv->ndev; 782 783 unregister_candev(ndev); 784 pm_runtime_disable(ndev->dev.parent); 785 } 786 787 static const struct of_device_id rkcanfd_of_match[] = { 788 { 789 .compatible = "rockchip,rk3568v2-canfd", 790 .data = &rkcanfd_devtype_data_rk3568v2, 791 }, { 792 .compatible = "rockchip,rk3568v3-canfd", 793 .data = &rkcanfd_devtype_data_rk3568v3, 794 }, { 795 /* sentinel */ 796 }, 797 }; 798 MODULE_DEVICE_TABLE(of, rkcanfd_of_match); 799 800 static int rkcanfd_probe(struct platform_device *pdev) 801 { 802 struct rkcanfd_priv *priv; 803 struct net_device *ndev; 804 const void *match; 805 int err; 806 807 ndev = alloc_candev(sizeof(struct rkcanfd_priv), RKCANFD_TXFIFO_DEPTH); 808 if (!ndev) 809 return -ENOMEM; 810 811 priv = netdev_priv(ndev); 812 813 ndev->irq = platform_get_irq(pdev, 0); 814 if (ndev->irq < 0) { 815 err = ndev->irq; 816 goto out_free_candev; 817 } 818 819 priv->clks_num = devm_clk_bulk_get_all(&pdev->dev, &priv->clks); 820 if (priv->clks_num < 0) { 821 err = priv->clks_num; 822 goto out_free_candev; 823 } 824 825 priv->regs = devm_platform_ioremap_resource(pdev, 0); 826 if (IS_ERR(priv->regs)) { 827 err = PTR_ERR(priv->regs); 828 goto out_free_candev; 829 } 830 831 priv->reset = devm_reset_control_array_get_exclusive(&pdev->dev); 832 if (IS_ERR(priv->reset)) { 833 err = dev_err_probe(&pdev->dev, PTR_ERR(priv->reset), 834 "Failed to get reset line\n"); 835 goto out_free_candev; 836 } 837 838 SET_NETDEV_DEV(ndev, &pdev->dev); 839 840 ndev->netdev_ops = &rkcanfd_netdev_ops; 841 ndev->flags |= IFF_ECHO; 842 843 platform_set_drvdata(pdev, priv); 844 priv->can.clock.freq = clk_get_rate(priv->clks[0].clk); 845 priv->can.bittiming_const = &rkcanfd_bittiming_const; 846 priv->can.data_bittiming_const = &rkcanfd_data_bittiming_const; 847 priv->can.ctrlmode_supported = 0; 848 if (!(priv->devtype_data.quirks & RKCANFD_QUIRK_CANFD_BROKEN)) 849 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD; 850 priv->can.do_set_mode = rkcanfd_set_mode; 851 priv->can.do_get_berr_counter = rkcanfd_get_berr_counter; 852 priv->ndev = ndev; 853 854 match = device_get_match_data(&pdev->dev); 855 if (match) 856 priv->devtype_data = *(struct rkcanfd_devtype_data *)match; 857 858 err = can_rx_offload_add_manual(ndev, &priv->offload, 859 RKCANFD_NAPI_WEIGHT); 860 if (err) 861 goto out_free_candev; 862 863 err = rkcanfd_register(priv); 864 if (err) 865 goto out_can_rx_offload_del; 866 867 return 0; 868 869 out_can_rx_offload_del: 870 can_rx_offload_del(&priv->offload); 871 out_free_candev: 872 free_candev(ndev); 873 874 return err; 875 } 876 877 static void rkcanfd_remove(struct platform_device *pdev) 878 { 879 struct rkcanfd_priv *priv = platform_get_drvdata(pdev); 880 struct net_device *ndev = priv->ndev; 881 882 can_rx_offload_del(&priv->offload); 883 rkcanfd_unregister(priv); 884 free_candev(ndev); 885 } 886 887 static const struct dev_pm_ops rkcanfd_pm_ops = { 888 SET_RUNTIME_PM_OPS(rkcanfd_runtime_suspend, 889 rkcanfd_runtime_resume, NULL) 890 }; 891 892 static struct platform_driver rkcanfd_driver = { 893 .driver = { 894 .name = DEVICE_NAME, 895 .pm = &rkcanfd_pm_ops, 896 .of_match_table = rkcanfd_of_match, 897 }, 898 .probe = rkcanfd_probe, 899 .remove = rkcanfd_remove, 900 }; 901 module_platform_driver(rkcanfd_driver); 902 903 MODULE_AUTHOR("Marc Kleine-Budde <mkl@pengutronix.de>"); 904 MODULE_DESCRIPTION("Rockchip CAN-FD Driver"); 905 MODULE_LICENSE("GPL"); 906