drivers/net/can/rockchip/rockchip_canfd-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Copyright (c) 2023, 2024 Pengutronix,
   4 //               Marc Kleine-Budde <[email protected]>
   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_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 read
 173          * 0x0, even if the controller is in warning mode
 174          * (RKCANFD_REG_STATE_ERROR_WARNING_STATE in RKCANFD_REG_STATE
 175          * set).
 176          *
 177          * In case both error counters read 0x0, use the struct
 178          * priv->bec, otherwise save the read value to priv->bec.
 179          *
 180          * rkcanfd_handle_rx_int_one() handles the decrementing of
 181          * priv->bec.rxerr for successfully RX'ed CAN frames.
 182          *
 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.
 187          *
 188          * rkcanfd_handle_tx_done_one() handles the decrementing of
 189          * priv->bec.txerr for successfully TX'ed CAN frames.
 190          */
 191         if (!bec->rxerr && !bec->txerr)
 192                 *bec = priv->bec;
 193         else
 194                 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
 205 static 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
 222 static 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
 230 static 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
 235 static 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
 254 static 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-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
 270          */
 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 interrupt
 286          * - TX_ARBIT_FAIL_INT - TX arbitration fail interrupt
 287          * - OVERLOAD_INT - CAN bus overload interrupt
 288          * - TX_FINISH_INT - Transmit finish interrupt
 289          */
 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 error
 297          * 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
 319 static 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
 327 static 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
 335 static 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
 343 static 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
 362 static struct sk_buff *
 363 rkcanfd_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
 377 static 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
 398 static void
 399 rkcanfd_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         else
 450                 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
 527 static 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, &timestamp);
 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
 564 static 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, &timestamp);
 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
 609 static int
 610 rkcanfd_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, &timestamp);
 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
 655 static 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 on
 667          * 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
 714 static 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
 740 out_rkcanfd_chip_stop:
 741         rkcanfd_chip_stop_sync(priv, CAN_STATE_STOPPED);
 742         pm_runtime_put(ndev->dev.parent);
 743 out_close_candev:
 744         close_candev(ndev);
 745         return err;
 746 }
 747
 748 static 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
 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,
 770 };
 771
 772 static 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
 781 static 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
 788 static 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
 809 static 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
 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);
 836
 837         return err;
 838 }
 839
 840 static 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
 848 static 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 };
 859 MODULE_DEVICE_TABLE(of, rkcanfd_of_match);
 860
 861 static 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
 931 out_can_rx_offload_del:
 932         can_rx_offload_del(&priv->offload);
 933 out_free_candev:
 934         free_candev(ndev);
 935
 936         return err;
 937 }
 938
 939 static 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
 949 static const struct dev_pm_ops rkcanfd_pm_ops = {
 950         SET_RUNTIME_PM_OPS(rkcanfd_runtime_suspend,
 951                            rkcanfd_runtime_resume, NULL)
 952 };
 953
 954 static 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 };
 963 module_platform_driver(rkcanfd_driver);
 964
 965 MODULE_AUTHOR("Marc Kleine-Budde <[email protected]>");
 966 MODULE_DESCRIPTION("Rockchip CAN-FD Driver");
 967 MODULE_LICENSE("GPL");