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
__rkcanfd_get_model_str(enum rkcanfd_model model)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 *
rkcanfd_get_model_str(const struct rkcanfd_priv * priv)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
rkcanfd_chip_set_reset_mode(const struct rkcanfd_priv * priv)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
rkcanfd_chip_set_work_mode(const struct rkcanfd_priv * priv)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
rkcanfd_set_bittiming(struct rkcanfd_priv * priv)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
rkcanfd_get_berr_counter_corrected(struct rkcanfd_priv * priv,struct can_berr_counter * bec)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
rkcanfd_get_berr_counter(const struct net_device * ndev,struct can_berr_counter * bec)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
rkcanfd_chip_interrupts_enable(const struct rkcanfd_priv * priv)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
rkcanfd_chip_interrupts_disable(const struct rkcanfd_priv * priv)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
rkcanfd_chip_fifo_setup(struct rkcanfd_priv * priv)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
rkcanfd_chip_start(struct rkcanfd_priv * priv)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
__rkcanfd_chip_stop(struct rkcanfd_priv * priv,const enum can_state state)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
rkcanfd_chip_stop(struct rkcanfd_priv * priv,const enum can_state state)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
rkcanfd_chip_stop_sync(struct rkcanfd_priv * priv,const enum can_state state)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
rkcanfd_set_mode(struct net_device * ndev,enum can_mode mode)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 *
rkcanfd_alloc_can_err_skb(struct rkcanfd_priv * priv,struct can_frame ** cf,u32 * timestamp)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
rkcanfd_get_error_type_str(unsigned int type)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
rkcanfd_handle_error_int_reg_ec(struct rkcanfd_priv * priv,struct can_frame * cf,const u32 reg_ec)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
rkcanfd_handle_error_int(struct rkcanfd_priv * priv)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
rkcanfd_handle_state_error_int(struct rkcanfd_priv * priv)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
rkcanfd_handle_rx_fifo_overflow_int(struct rkcanfd_priv * priv)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
rkcanfd_irq(int irq,void * dev_id)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
rkcanfd_open(struct net_device * ndev)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
rkcanfd_stop(struct net_device * ndev)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
rkcanfd_runtime_suspend(struct device * dev)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
rkcanfd_runtime_resume(struct device * dev)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
rkcanfd_register_done(const struct rkcanfd_priv * priv)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
rkcanfd_register(struct rkcanfd_priv * priv)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
rkcanfd_unregister(struct rkcanfd_priv * priv)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
rkcanfd_probe(struct platform_device * pdev)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
rkcanfd_remove(struct platform_device * pdev)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