2 * flexcan.c - FLEXCAN CAN controller driver
4 * Copyright (c) 2005-2006 Varma Electronics Oy
5 * Copyright (c) 2009 Sascha Hauer, Pengutronix
6 * Copyright (c) 2010-2017 Pengutronix, Marc Kleine-Budde <kernel@pengutronix.de>
7 * Copyright (c) 2014 David Jander, Protonic Holland
9 * Based on code originally by Andrey Volkov <avolkov@varma-el.com>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation version 2.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
23 #include <linux/netdevice.h>
24 #include <linux/can.h>
25 #include <linux/can/dev.h>
26 #include <linux/can/error.h>
27 #include <linux/can/led.h>
28 #include <linux/can/rx-offload.h>
29 #include <linux/clk.h>
30 #include <linux/delay.h>
31 #include <linux/interrupt.h>
33 #include <linux/module.h>
35 #include <linux/of_device.h>
36 #include <linux/platform_device.h>
37 #include <linux/regulator/consumer.h>
39 #define DRV_NAME "flexcan"
41 /* 8 for RX fifo and 2 error handling */
42 #define FLEXCAN_NAPI_WEIGHT (8 + 2)
44 /* FLEXCAN module configuration register (CANMCR) bits */
45 #define FLEXCAN_MCR_MDIS BIT(31)
46 #define FLEXCAN_MCR_FRZ BIT(30)
47 #define FLEXCAN_MCR_FEN BIT(29)
48 #define FLEXCAN_MCR_HALT BIT(28)
49 #define FLEXCAN_MCR_NOT_RDY BIT(27)
50 #define FLEXCAN_MCR_WAK_MSK BIT(26)
51 #define FLEXCAN_MCR_SOFTRST BIT(25)
52 #define FLEXCAN_MCR_FRZ_ACK BIT(24)
53 #define FLEXCAN_MCR_SUPV BIT(23)
54 #define FLEXCAN_MCR_SLF_WAK BIT(22)
55 #define FLEXCAN_MCR_WRN_EN BIT(21)
56 #define FLEXCAN_MCR_LPM_ACK BIT(20)
57 #define FLEXCAN_MCR_WAK_SRC BIT(19)
58 #define FLEXCAN_MCR_DOZE BIT(18)
59 #define FLEXCAN_MCR_SRX_DIS BIT(17)
60 #define FLEXCAN_MCR_IRMQ BIT(16)
61 #define FLEXCAN_MCR_LPRIO_EN BIT(13)
62 #define FLEXCAN_MCR_AEN BIT(12)
63 /* MCR_MAXMB: maximum used MBs is MAXMB + 1 */
64 #define FLEXCAN_MCR_MAXMB(x) ((x) & 0x7f)
65 #define FLEXCAN_MCR_IDAM_A (0x0 << 8)
66 #define FLEXCAN_MCR_IDAM_B (0x1 << 8)
67 #define FLEXCAN_MCR_IDAM_C (0x2 << 8)
68 #define FLEXCAN_MCR_IDAM_D (0x3 << 8)
70 /* FLEXCAN control register (CANCTRL) bits */
71 #define FLEXCAN_CTRL_PRESDIV(x) (((x) & 0xff) << 24)
72 #define FLEXCAN_CTRL_RJW(x) (((x) & 0x03) << 22)
73 #define FLEXCAN_CTRL_PSEG1(x) (((x) & 0x07) << 19)
74 #define FLEXCAN_CTRL_PSEG2(x) (((x) & 0x07) << 16)
75 #define FLEXCAN_CTRL_BOFF_MSK BIT(15)
76 #define FLEXCAN_CTRL_ERR_MSK BIT(14)
77 #define FLEXCAN_CTRL_CLK_SRC BIT(13)
78 #define FLEXCAN_CTRL_LPB BIT(12)
79 #define FLEXCAN_CTRL_TWRN_MSK BIT(11)
80 #define FLEXCAN_CTRL_RWRN_MSK BIT(10)
81 #define FLEXCAN_CTRL_SMP BIT(7)
82 #define FLEXCAN_CTRL_BOFF_REC BIT(6)
83 #define FLEXCAN_CTRL_TSYN BIT(5)
84 #define FLEXCAN_CTRL_LBUF BIT(4)
85 #define FLEXCAN_CTRL_LOM BIT(3)
86 #define FLEXCAN_CTRL_PROPSEG(x) ((x) & 0x07)
87 #define FLEXCAN_CTRL_ERR_BUS (FLEXCAN_CTRL_ERR_MSK)
88 #define FLEXCAN_CTRL_ERR_STATE \
89 (FLEXCAN_CTRL_TWRN_MSK | FLEXCAN_CTRL_RWRN_MSK | \
90 FLEXCAN_CTRL_BOFF_MSK)
91 #define FLEXCAN_CTRL_ERR_ALL \
92 (FLEXCAN_CTRL_ERR_BUS | FLEXCAN_CTRL_ERR_STATE)
94 /* FLEXCAN control register 2 (CTRL2) bits */
95 #define FLEXCAN_CTRL2_ECRWRE BIT(29)
96 #define FLEXCAN_CTRL2_WRMFRZ BIT(28)
97 #define FLEXCAN_CTRL2_RFFN(x) (((x) & 0x0f) << 24)
98 #define FLEXCAN_CTRL2_TASD(x) (((x) & 0x1f) << 19)
99 #define FLEXCAN_CTRL2_MRP BIT(18)
100 #define FLEXCAN_CTRL2_RRS BIT(17)
101 #define FLEXCAN_CTRL2_EACEN BIT(16)
103 /* FLEXCAN memory error control register (MECR) bits */
104 #define FLEXCAN_MECR_ECRWRDIS BIT(31)
105 #define FLEXCAN_MECR_HANCEI_MSK BIT(19)
106 #define FLEXCAN_MECR_FANCEI_MSK BIT(18)
107 #define FLEXCAN_MECR_CEI_MSK BIT(16)
108 #define FLEXCAN_MECR_HAERRIE BIT(15)
109 #define FLEXCAN_MECR_FAERRIE BIT(14)
110 #define FLEXCAN_MECR_EXTERRIE BIT(13)
111 #define FLEXCAN_MECR_RERRDIS BIT(9)
112 #define FLEXCAN_MECR_ECCDIS BIT(8)
113 #define FLEXCAN_MECR_NCEFAFRZ BIT(7)
115 /* FLEXCAN error and status register (ESR) bits */
116 #define FLEXCAN_ESR_TWRN_INT BIT(17)
117 #define FLEXCAN_ESR_RWRN_INT BIT(16)
118 #define FLEXCAN_ESR_BIT1_ERR BIT(15)
119 #define FLEXCAN_ESR_BIT0_ERR BIT(14)
120 #define FLEXCAN_ESR_ACK_ERR BIT(13)
121 #define FLEXCAN_ESR_CRC_ERR BIT(12)
122 #define FLEXCAN_ESR_FRM_ERR BIT(11)
123 #define FLEXCAN_ESR_STF_ERR BIT(10)
124 #define FLEXCAN_ESR_TX_WRN BIT(9)
125 #define FLEXCAN_ESR_RX_WRN BIT(8)
126 #define FLEXCAN_ESR_IDLE BIT(7)
127 #define FLEXCAN_ESR_TXRX BIT(6)
128 #define FLEXCAN_EST_FLT_CONF_SHIFT (4)
129 #define FLEXCAN_ESR_FLT_CONF_MASK (0x3 << FLEXCAN_EST_FLT_CONF_SHIFT)
130 #define FLEXCAN_ESR_FLT_CONF_ACTIVE (0x0 << FLEXCAN_EST_FLT_CONF_SHIFT)
131 #define FLEXCAN_ESR_FLT_CONF_PASSIVE (0x1 << FLEXCAN_EST_FLT_CONF_SHIFT)
132 #define FLEXCAN_ESR_BOFF_INT BIT(2)
133 #define FLEXCAN_ESR_ERR_INT BIT(1)
134 #define FLEXCAN_ESR_WAK_INT BIT(0)
135 #define FLEXCAN_ESR_ERR_BUS \
136 (FLEXCAN_ESR_BIT1_ERR | FLEXCAN_ESR_BIT0_ERR | \
137 FLEXCAN_ESR_ACK_ERR | FLEXCAN_ESR_CRC_ERR | \
138 FLEXCAN_ESR_FRM_ERR | FLEXCAN_ESR_STF_ERR)
139 #define FLEXCAN_ESR_ERR_STATE \
140 (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | FLEXCAN_ESR_BOFF_INT)
141 #define FLEXCAN_ESR_ERR_ALL \
142 (FLEXCAN_ESR_ERR_BUS | FLEXCAN_ESR_ERR_STATE)
143 #define FLEXCAN_ESR_ALL_INT \
144 (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | \
145 FLEXCAN_ESR_BOFF_INT | FLEXCAN_ESR_ERR_INT)
147 /* FLEXCAN interrupt flag register (IFLAG) bits */
148 /* Errata ERR005829 step7: Reserve first valid MB */
149 #define FLEXCAN_TX_MB_RESERVED_OFF_FIFO 8
150 #define FLEXCAN_TX_MB_OFF_FIFO 9
151 #define FLEXCAN_TX_MB_RESERVED_OFF_TIMESTAMP 0
152 #define FLEXCAN_TX_MB_OFF_TIMESTAMP 1
153 #define FLEXCAN_RX_MB_OFF_TIMESTAMP_FIRST (FLEXCAN_TX_MB_OFF_TIMESTAMP + 1)
154 #define FLEXCAN_RX_MB_OFF_TIMESTAMP_LAST 63
155 #define FLEXCAN_IFLAG_MB(x) BIT(x)
156 #define FLEXCAN_IFLAG_RX_FIFO_OVERFLOW BIT(7)
157 #define FLEXCAN_IFLAG_RX_FIFO_WARN BIT(6)
158 #define FLEXCAN_IFLAG_RX_FIFO_AVAILABLE BIT(5)
160 /* FLEXCAN message buffers */
161 #define FLEXCAN_MB_CODE_MASK (0xf << 24)
162 #define FLEXCAN_MB_CODE_RX_BUSY_BIT (0x1 << 24)
163 #define FLEXCAN_MB_CODE_RX_INACTIVE (0x0 << 24)
164 #define FLEXCAN_MB_CODE_RX_EMPTY (0x4 << 24)
165 #define FLEXCAN_MB_CODE_RX_FULL (0x2 << 24)
166 #define FLEXCAN_MB_CODE_RX_OVERRUN (0x6 << 24)
167 #define FLEXCAN_MB_CODE_RX_RANSWER (0xa << 24)
169 #define FLEXCAN_MB_CODE_TX_INACTIVE (0x8 << 24)
170 #define FLEXCAN_MB_CODE_TX_ABORT (0x9 << 24)
171 #define FLEXCAN_MB_CODE_TX_DATA (0xc << 24)
172 #define FLEXCAN_MB_CODE_TX_TANSWER (0xe << 24)
174 #define FLEXCAN_MB_CNT_SRR BIT(22)
175 #define FLEXCAN_MB_CNT_IDE BIT(21)
176 #define FLEXCAN_MB_CNT_RTR BIT(20)
177 #define FLEXCAN_MB_CNT_LENGTH(x) (((x) & 0xf) << 16)
178 #define FLEXCAN_MB_CNT_TIMESTAMP(x) ((x) & 0xffff)
180 #define FLEXCAN_TIMEOUT_US (50)
182 /* FLEXCAN hardware feature flags
184 * Below is some version info we got:
185 * SOC Version IP-Version Glitch- [TR]WRN_INT IRQ Err Memory err RTR re-
186 * Filter? connected? Passive detection ception in MB
187 * MX25 FlexCAN2 03.00.00.00 no no ? no no
188 * MX28 FlexCAN2 03.00.04.00 yes yes no no no
189 * MX35 FlexCAN2 03.00.00.00 no no ? no no
190 * MX53 FlexCAN2 03.00.00.00 yes no no no no
191 * MX6s FlexCAN3 10.00.12.00 yes yes no no yes
192 * VF610 FlexCAN3 ? no yes ? yes yes?
194 * Some SOCs do not have the RX_WARN & TX_WARN interrupt line connected.
196 #define FLEXCAN_QUIRK_BROKEN_WERR_STATE BIT(1) /* [TR]WRN_INT not connected */
197 #define FLEXCAN_QUIRK_DISABLE_RXFG BIT(2) /* Disable RX FIFO Global mask */
198 #define FLEXCAN_QUIRK_ENABLE_EACEN_RRS BIT(3) /* Enable EACEN and RRS bit in ctrl2 */
199 #define FLEXCAN_QUIRK_DISABLE_MECR BIT(4) /* Disable Memory error detection */
200 #define FLEXCAN_QUIRK_USE_OFF_TIMESTAMP BIT(5) /* Use timestamp based offloading */
201 #define FLEXCAN_QUIRK_BROKEN_PERR_STATE BIT(6) /* No interrupt for error passive */
203 /* Structure of the message buffer */
210 /* Structure of the hardware registers */
211 struct flexcan_regs
{
214 u32 timer
; /* 0x08 */
215 u32 _reserved1
; /* 0x0c */
216 u32 rxgmask
; /* 0x10 */
217 u32 rx14mask
; /* 0x14 */
218 u32 rx15mask
; /* 0x18 */
221 u32 imask2
; /* 0x24 */
222 u32 imask1
; /* 0x28 */
223 u32 iflag2
; /* 0x2c */
224 u32 iflag1
; /* 0x30 */
226 u32 gfwr_mx28
; /* MX28, MX53 */
227 u32 ctrl2
; /* MX6, VF610 */
230 u32 imeur
; /* 0x3c */
233 u32 rxfgmask
; /* 0x48 */
234 u32 rxfir
; /* 0x4c */
235 u32 _reserved3
[12]; /* 0x50 */
236 struct flexcan_mb mb
[64]; /* 0x80 */
239 * 0x080...0x08f 0 RX message buffer
240 * 0x090...0x0df 1-5 reserverd
241 * 0x0e0...0x0ff 6-7 8 entry ID table
242 * (mx25, mx28, mx35, mx53)
243 * 0x0e0...0x2df 6-7..37 8..128 entry ID table
244 * size conf'ed via ctrl2::RFFN
247 u32 _reserved4
[256]; /* 0x480 */
248 u32 rximr
[64]; /* 0x880 */
249 u32 _reserved5
[24]; /* 0x980 */
250 u32 gfwr_mx6
; /* 0x9e0 - MX6 */
251 u32 _reserved6
[63]; /* 0x9e4 */
252 u32 mecr
; /* 0xae0 */
253 u32 erriar
; /* 0xae4 */
254 u32 erridpr
; /* 0xae8 */
255 u32 errippr
; /* 0xaec */
256 u32 rerrar
; /* 0xaf0 */
257 u32 rerrdr
; /* 0xaf4 */
258 u32 rerrsynr
; /* 0xaf8 */
259 u32 errsr
; /* 0xafc */
262 struct flexcan_devtype_data
{
263 u32 quirks
; /* quirks needed for different IP cores */
266 struct flexcan_priv
{
268 struct can_rx_offload offload
;
270 struct flexcan_regs __iomem
*regs
;
271 struct flexcan_mb __iomem
*tx_mb
;
272 struct flexcan_mb __iomem
*tx_mb_reserved
;
274 u32 reg_ctrl_default
;
275 u32 reg_imask1_default
;
276 u32 reg_imask2_default
;
280 const struct flexcan_devtype_data
*devtype_data
;
281 struct regulator
*reg_xceiver
;
284 static const struct flexcan_devtype_data fsl_p1010_devtype_data
= {
285 .quirks
= FLEXCAN_QUIRK_BROKEN_WERR_STATE
|
286 FLEXCAN_QUIRK_BROKEN_PERR_STATE
,
289 static const struct flexcan_devtype_data fsl_imx28_devtype_data
= {
290 .quirks
= FLEXCAN_QUIRK_BROKEN_PERR_STATE
,
293 static const struct flexcan_devtype_data fsl_imx6q_devtype_data
= {
294 .quirks
= FLEXCAN_QUIRK_DISABLE_RXFG
| FLEXCAN_QUIRK_ENABLE_EACEN_RRS
|
295 FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
| FLEXCAN_QUIRK_BROKEN_PERR_STATE
,
298 static const struct flexcan_devtype_data fsl_vf610_devtype_data
= {
299 .quirks
= FLEXCAN_QUIRK_DISABLE_RXFG
| FLEXCAN_QUIRK_ENABLE_EACEN_RRS
|
300 FLEXCAN_QUIRK_DISABLE_MECR
| FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
,
303 static const struct can_bittiming_const flexcan_bittiming_const
= {
315 /* Abstract off the read/write for arm versus ppc. This
316 * assumes that PPC uses big-endian registers and everything
317 * else uses little-endian registers, independent of CPU
320 #if defined(CONFIG_PPC)
321 static inline u32
flexcan_read(void __iomem
*addr
)
323 return in_be32(addr
);
326 static inline void flexcan_write(u32 val
, void __iomem
*addr
)
331 static inline u32
flexcan_read(void __iomem
*addr
)
336 static inline void flexcan_write(u32 val
, void __iomem
*addr
)
342 static inline void flexcan_error_irq_enable(const struct flexcan_priv
*priv
)
344 struct flexcan_regs __iomem
*regs
= priv
->regs
;
345 u32 reg_ctrl
= (priv
->reg_ctrl_default
| FLEXCAN_CTRL_ERR_MSK
);
347 flexcan_write(reg_ctrl
, ®s
->ctrl
);
350 static inline void flexcan_error_irq_disable(const struct flexcan_priv
*priv
)
352 struct flexcan_regs __iomem
*regs
= priv
->regs
;
353 u32 reg_ctrl
= (priv
->reg_ctrl_default
& ~FLEXCAN_CTRL_ERR_MSK
);
355 flexcan_write(reg_ctrl
, ®s
->ctrl
);
358 static inline int flexcan_transceiver_enable(const struct flexcan_priv
*priv
)
360 if (!priv
->reg_xceiver
)
363 return regulator_enable(priv
->reg_xceiver
);
366 static inline int flexcan_transceiver_disable(const struct flexcan_priv
*priv
)
368 if (!priv
->reg_xceiver
)
371 return regulator_disable(priv
->reg_xceiver
);
374 static int flexcan_chip_enable(struct flexcan_priv
*priv
)
376 struct flexcan_regs __iomem
*regs
= priv
->regs
;
377 unsigned int timeout
= FLEXCAN_TIMEOUT_US
/ 10;
380 reg
= flexcan_read(®s
->mcr
);
381 reg
&= ~FLEXCAN_MCR_MDIS
;
382 flexcan_write(reg
, ®s
->mcr
);
384 while (timeout
-- && (flexcan_read(®s
->mcr
) & FLEXCAN_MCR_LPM_ACK
))
387 if (flexcan_read(®s
->mcr
) & FLEXCAN_MCR_LPM_ACK
)
393 static int flexcan_chip_disable(struct flexcan_priv
*priv
)
395 struct flexcan_regs __iomem
*regs
= priv
->regs
;
396 unsigned int timeout
= FLEXCAN_TIMEOUT_US
/ 10;
399 reg
= flexcan_read(®s
->mcr
);
400 reg
|= FLEXCAN_MCR_MDIS
;
401 flexcan_write(reg
, ®s
->mcr
);
403 while (timeout
-- && !(flexcan_read(®s
->mcr
) & FLEXCAN_MCR_LPM_ACK
))
406 if (!(flexcan_read(®s
->mcr
) & FLEXCAN_MCR_LPM_ACK
))
412 static int flexcan_chip_freeze(struct flexcan_priv
*priv
)
414 struct flexcan_regs __iomem
*regs
= priv
->regs
;
415 unsigned int timeout
= 1000 * 1000 * 10 / priv
->can
.bittiming
.bitrate
;
418 reg
= flexcan_read(®s
->mcr
);
419 reg
|= FLEXCAN_MCR_HALT
;
420 flexcan_write(reg
, ®s
->mcr
);
422 while (timeout
-- && !(flexcan_read(®s
->mcr
) & FLEXCAN_MCR_FRZ_ACK
))
425 if (!(flexcan_read(®s
->mcr
) & FLEXCAN_MCR_FRZ_ACK
))
431 static int flexcan_chip_unfreeze(struct flexcan_priv
*priv
)
433 struct flexcan_regs __iomem
*regs
= priv
->regs
;
434 unsigned int timeout
= FLEXCAN_TIMEOUT_US
/ 10;
437 reg
= flexcan_read(®s
->mcr
);
438 reg
&= ~FLEXCAN_MCR_HALT
;
439 flexcan_write(reg
, ®s
->mcr
);
441 while (timeout
-- && (flexcan_read(®s
->mcr
) & FLEXCAN_MCR_FRZ_ACK
))
444 if (flexcan_read(®s
->mcr
) & FLEXCAN_MCR_FRZ_ACK
)
450 static int flexcan_chip_softreset(struct flexcan_priv
*priv
)
452 struct flexcan_regs __iomem
*regs
= priv
->regs
;
453 unsigned int timeout
= FLEXCAN_TIMEOUT_US
/ 10;
455 flexcan_write(FLEXCAN_MCR_SOFTRST
, ®s
->mcr
);
456 while (timeout
-- && (flexcan_read(®s
->mcr
) & FLEXCAN_MCR_SOFTRST
))
459 if (flexcan_read(®s
->mcr
) & FLEXCAN_MCR_SOFTRST
)
465 static int __flexcan_get_berr_counter(const struct net_device
*dev
,
466 struct can_berr_counter
*bec
)
468 const struct flexcan_priv
*priv
= netdev_priv(dev
);
469 struct flexcan_regs __iomem
*regs
= priv
->regs
;
470 u32 reg
= flexcan_read(®s
->ecr
);
472 bec
->txerr
= (reg
>> 0) & 0xff;
473 bec
->rxerr
= (reg
>> 8) & 0xff;
478 static int flexcan_get_berr_counter(const struct net_device
*dev
,
479 struct can_berr_counter
*bec
)
481 const struct flexcan_priv
*priv
= netdev_priv(dev
);
484 err
= clk_prepare_enable(priv
->clk_ipg
);
488 err
= clk_prepare_enable(priv
->clk_per
);
490 goto out_disable_ipg
;
492 err
= __flexcan_get_berr_counter(dev
, bec
);
494 clk_disable_unprepare(priv
->clk_per
);
496 clk_disable_unprepare(priv
->clk_ipg
);
501 static int flexcan_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
503 const struct flexcan_priv
*priv
= netdev_priv(dev
);
504 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
507 u32 ctrl
= FLEXCAN_MB_CODE_TX_DATA
| (cf
->can_dlc
<< 16);
509 if (can_dropped_invalid_skb(dev
, skb
))
512 netif_stop_queue(dev
);
514 if (cf
->can_id
& CAN_EFF_FLAG
) {
515 can_id
= cf
->can_id
& CAN_EFF_MASK
;
516 ctrl
|= FLEXCAN_MB_CNT_IDE
| FLEXCAN_MB_CNT_SRR
;
518 can_id
= (cf
->can_id
& CAN_SFF_MASK
) << 18;
521 if (cf
->can_id
& CAN_RTR_FLAG
)
522 ctrl
|= FLEXCAN_MB_CNT_RTR
;
524 if (cf
->can_dlc
> 0) {
525 data
= be32_to_cpup((__be32
*)&cf
->data
[0]);
526 flexcan_write(data
, &priv
->tx_mb
->data
[0]);
528 if (cf
->can_dlc
> 3) {
529 data
= be32_to_cpup((__be32
*)&cf
->data
[4]);
530 flexcan_write(data
, &priv
->tx_mb
->data
[1]);
533 can_put_echo_skb(skb
, dev
, 0);
535 flexcan_write(can_id
, &priv
->tx_mb
->can_id
);
536 flexcan_write(ctrl
, &priv
->tx_mb
->can_ctrl
);
538 /* Errata ERR005829 step8:
539 * Write twice INACTIVE(0x8) code to first MB.
541 flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE
,
542 &priv
->tx_mb_reserved
->can_ctrl
);
543 flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE
,
544 &priv
->tx_mb_reserved
->can_ctrl
);
549 static void flexcan_irq_bus_err(struct net_device
*dev
, u32 reg_esr
)
551 struct flexcan_priv
*priv
= netdev_priv(dev
);
553 struct can_frame
*cf
;
554 bool rx_errors
= false, tx_errors
= false;
556 skb
= alloc_can_err_skb(dev
, &cf
);
560 cf
->can_id
|= CAN_ERR_PROT
| CAN_ERR_BUSERROR
;
562 if (reg_esr
& FLEXCAN_ESR_BIT1_ERR
) {
563 netdev_dbg(dev
, "BIT1_ERR irq\n");
564 cf
->data
[2] |= CAN_ERR_PROT_BIT1
;
567 if (reg_esr
& FLEXCAN_ESR_BIT0_ERR
) {
568 netdev_dbg(dev
, "BIT0_ERR irq\n");
569 cf
->data
[2] |= CAN_ERR_PROT_BIT0
;
572 if (reg_esr
& FLEXCAN_ESR_ACK_ERR
) {
573 netdev_dbg(dev
, "ACK_ERR irq\n");
574 cf
->can_id
|= CAN_ERR_ACK
;
575 cf
->data
[3] = CAN_ERR_PROT_LOC_ACK
;
578 if (reg_esr
& FLEXCAN_ESR_CRC_ERR
) {
579 netdev_dbg(dev
, "CRC_ERR irq\n");
580 cf
->data
[2] |= CAN_ERR_PROT_BIT
;
581 cf
->data
[3] = CAN_ERR_PROT_LOC_CRC_SEQ
;
584 if (reg_esr
& FLEXCAN_ESR_FRM_ERR
) {
585 netdev_dbg(dev
, "FRM_ERR irq\n");
586 cf
->data
[2] |= CAN_ERR_PROT_FORM
;
589 if (reg_esr
& FLEXCAN_ESR_STF_ERR
) {
590 netdev_dbg(dev
, "STF_ERR irq\n");
591 cf
->data
[2] |= CAN_ERR_PROT_STUFF
;
595 priv
->can
.can_stats
.bus_error
++;
597 dev
->stats
.rx_errors
++;
599 dev
->stats
.tx_errors
++;
601 can_rx_offload_irq_queue_err_skb(&priv
->offload
, skb
);
604 static void flexcan_irq_state(struct net_device
*dev
, u32 reg_esr
)
606 struct flexcan_priv
*priv
= netdev_priv(dev
);
608 struct can_frame
*cf
;
609 enum can_state new_state
, rx_state
, tx_state
;
611 struct can_berr_counter bec
;
613 flt
= reg_esr
& FLEXCAN_ESR_FLT_CONF_MASK
;
614 if (likely(flt
== FLEXCAN_ESR_FLT_CONF_ACTIVE
)) {
615 tx_state
= unlikely(reg_esr
& FLEXCAN_ESR_TX_WRN
) ?
616 CAN_STATE_ERROR_WARNING
: CAN_STATE_ERROR_ACTIVE
;
617 rx_state
= unlikely(reg_esr
& FLEXCAN_ESR_RX_WRN
) ?
618 CAN_STATE_ERROR_WARNING
: CAN_STATE_ERROR_ACTIVE
;
619 new_state
= max(tx_state
, rx_state
);
621 __flexcan_get_berr_counter(dev
, &bec
);
622 new_state
= flt
== FLEXCAN_ESR_FLT_CONF_PASSIVE
?
623 CAN_STATE_ERROR_PASSIVE
: CAN_STATE_BUS_OFF
;
624 rx_state
= bec
.rxerr
>= bec
.txerr
? new_state
: 0;
625 tx_state
= bec
.rxerr
<= bec
.txerr
? new_state
: 0;
628 /* state hasn't changed */
629 if (likely(new_state
== priv
->can
.state
))
632 skb
= alloc_can_err_skb(dev
, &cf
);
636 can_change_state(dev
, cf
, tx_state
, rx_state
);
638 if (unlikely(new_state
== CAN_STATE_BUS_OFF
))
641 can_rx_offload_irq_queue_err_skb(&priv
->offload
, skb
);
644 static inline struct flexcan_priv
*rx_offload_to_priv(struct can_rx_offload
*offload
)
646 return container_of(offload
, struct flexcan_priv
, offload
);
649 static unsigned int flexcan_mailbox_read(struct can_rx_offload
*offload
,
650 struct can_frame
*cf
,
651 u32
*timestamp
, unsigned int n
)
653 struct flexcan_priv
*priv
= rx_offload_to_priv(offload
);
654 struct flexcan_regs __iomem
*regs
= priv
->regs
;
655 struct flexcan_mb __iomem
*mb
= ®s
->mb
[n
];
656 u32 reg_ctrl
, reg_id
, reg_iflag1
;
658 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
662 reg_ctrl
= flexcan_read(&mb
->can_ctrl
);
663 } while (reg_ctrl
& FLEXCAN_MB_CODE_RX_BUSY_BIT
);
665 /* is this MB empty? */
666 code
= reg_ctrl
& FLEXCAN_MB_CODE_MASK
;
667 if ((code
!= FLEXCAN_MB_CODE_RX_FULL
) &&
668 (code
!= FLEXCAN_MB_CODE_RX_OVERRUN
))
671 if (code
== FLEXCAN_MB_CODE_RX_OVERRUN
) {
672 /* This MB was overrun, we lost data */
673 offload
->dev
->stats
.rx_over_errors
++;
674 offload
->dev
->stats
.rx_errors
++;
677 reg_iflag1
= flexcan_read(®s
->iflag1
);
678 if (!(reg_iflag1
& FLEXCAN_IFLAG_RX_FIFO_AVAILABLE
))
681 reg_ctrl
= flexcan_read(&mb
->can_ctrl
);
684 /* increase timstamp to full 32 bit */
685 *timestamp
= reg_ctrl
<< 16;
687 reg_id
= flexcan_read(&mb
->can_id
);
688 if (reg_ctrl
& FLEXCAN_MB_CNT_IDE
)
689 cf
->can_id
= ((reg_id
>> 0) & CAN_EFF_MASK
) | CAN_EFF_FLAG
;
691 cf
->can_id
= (reg_id
>> 18) & CAN_SFF_MASK
;
693 if (reg_ctrl
& FLEXCAN_MB_CNT_RTR
)
694 cf
->can_id
|= CAN_RTR_FLAG
;
695 cf
->can_dlc
= get_can_dlc((reg_ctrl
>> 16) & 0xf);
697 *(__be32
*)(cf
->data
+ 0) = cpu_to_be32(flexcan_read(&mb
->data
[0]));
698 *(__be32
*)(cf
->data
+ 4) = cpu_to_be32(flexcan_read(&mb
->data
[1]));
701 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
704 flexcan_write(BIT(n
), ®s
->iflag1
);
706 flexcan_write(BIT(n
- 32), ®s
->iflag2
);
708 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE
, ®s
->iflag1
);
709 flexcan_read(®s
->timer
);
716 static inline u64
flexcan_read_reg_iflag_rx(struct flexcan_priv
*priv
)
718 struct flexcan_regs __iomem
*regs
= priv
->regs
;
721 iflag2
= flexcan_read(®s
->iflag2
) & priv
->reg_imask2_default
;
722 iflag1
= flexcan_read(®s
->iflag1
) & priv
->reg_imask1_default
&
723 ~FLEXCAN_IFLAG_MB(priv
->tx_mb_idx
);
725 return (u64
)iflag2
<< 32 | iflag1
;
728 static irqreturn_t
flexcan_irq(int irq
, void *dev_id
)
730 struct net_device
*dev
= dev_id
;
731 struct net_device_stats
*stats
= &dev
->stats
;
732 struct flexcan_priv
*priv
= netdev_priv(dev
);
733 struct flexcan_regs __iomem
*regs
= priv
->regs
;
734 irqreturn_t handled
= IRQ_NONE
;
735 u32 reg_iflag1
, reg_esr
;
736 enum can_state last_state
= priv
->can
.state
;
738 reg_iflag1
= flexcan_read(®s
->iflag1
);
740 /* reception interrupt */
741 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
745 while ((reg_iflag
= flexcan_read_reg_iflag_rx(priv
))) {
746 handled
= IRQ_HANDLED
;
747 ret
= can_rx_offload_irq_offload_timestamp(&priv
->offload
,
753 if (reg_iflag1
& FLEXCAN_IFLAG_RX_FIFO_AVAILABLE
) {
754 handled
= IRQ_HANDLED
;
755 can_rx_offload_irq_offload_fifo(&priv
->offload
);
758 /* FIFO overflow interrupt */
759 if (reg_iflag1
& FLEXCAN_IFLAG_RX_FIFO_OVERFLOW
) {
760 handled
= IRQ_HANDLED
;
761 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW
, ®s
->iflag1
);
762 dev
->stats
.rx_over_errors
++;
763 dev
->stats
.rx_errors
++;
767 /* transmission complete interrupt */
768 if (reg_iflag1
& FLEXCAN_IFLAG_MB(priv
->tx_mb_idx
)) {
769 handled
= IRQ_HANDLED
;
770 stats
->tx_bytes
+= can_get_echo_skb(dev
, 0);
772 can_led_event(dev
, CAN_LED_EVENT_TX
);
774 /* after sending a RTR frame MB is in RX mode */
775 flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE
,
776 &priv
->tx_mb
->can_ctrl
);
777 flexcan_write(FLEXCAN_IFLAG_MB(priv
->tx_mb_idx
), ®s
->iflag1
);
778 netif_wake_queue(dev
);
781 reg_esr
= flexcan_read(®s
->esr
);
783 /* ACK all bus error and state change IRQ sources */
784 if (reg_esr
& FLEXCAN_ESR_ALL_INT
) {
785 handled
= IRQ_HANDLED
;
786 flexcan_write(reg_esr
& FLEXCAN_ESR_ALL_INT
, ®s
->esr
);
789 /* state change interrupt or broken error state quirk fix is enabled */
790 if ((reg_esr
& FLEXCAN_ESR_ERR_STATE
) ||
791 (priv
->devtype_data
->quirks
& (FLEXCAN_QUIRK_BROKEN_WERR_STATE
|
792 FLEXCAN_QUIRK_BROKEN_PERR_STATE
)))
793 flexcan_irq_state(dev
, reg_esr
);
795 /* bus error IRQ - handle if bus error reporting is activated */
796 if ((reg_esr
& FLEXCAN_ESR_ERR_BUS
) &&
797 (priv
->can
.ctrlmode
& CAN_CTRLMODE_BERR_REPORTING
))
798 flexcan_irq_bus_err(dev
, reg_esr
);
800 /* availability of error interrupt among state transitions in case
801 * bus error reporting is de-activated and
802 * FLEXCAN_QUIRK_BROKEN_PERR_STATE is enabled:
803 * +--------------------------------------------------------------+
804 * | +----------------------------------------------+ [stopped / |
806 * +-+-> active <-> warning <-> passive -> bus off -+
807 * ___________^^^^^^^^^^^^_______________________________
808 * disabled(1) enabled disabled
810 * (1): enabled if FLEXCAN_QUIRK_BROKEN_WERR_STATE is enabled
812 if ((last_state
!= priv
->can
.state
) &&
813 (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_BROKEN_PERR_STATE
) &&
814 !(priv
->can
.ctrlmode
& CAN_CTRLMODE_BERR_REPORTING
)) {
815 switch (priv
->can
.state
) {
816 case CAN_STATE_ERROR_ACTIVE
:
817 if (priv
->devtype_data
->quirks
&
818 FLEXCAN_QUIRK_BROKEN_WERR_STATE
)
819 flexcan_error_irq_enable(priv
);
821 flexcan_error_irq_disable(priv
);
824 case CAN_STATE_ERROR_WARNING
:
825 flexcan_error_irq_enable(priv
);
828 case CAN_STATE_ERROR_PASSIVE
:
829 case CAN_STATE_BUS_OFF
:
830 flexcan_error_irq_disable(priv
);
841 static void flexcan_set_bittiming(struct net_device
*dev
)
843 const struct flexcan_priv
*priv
= netdev_priv(dev
);
844 const struct can_bittiming
*bt
= &priv
->can
.bittiming
;
845 struct flexcan_regs __iomem
*regs
= priv
->regs
;
848 reg
= flexcan_read(®s
->ctrl
);
849 reg
&= ~(FLEXCAN_CTRL_PRESDIV(0xff) |
850 FLEXCAN_CTRL_RJW(0x3) |
851 FLEXCAN_CTRL_PSEG1(0x7) |
852 FLEXCAN_CTRL_PSEG2(0x7) |
853 FLEXCAN_CTRL_PROPSEG(0x7) |
858 reg
|= FLEXCAN_CTRL_PRESDIV(bt
->brp
- 1) |
859 FLEXCAN_CTRL_PSEG1(bt
->phase_seg1
- 1) |
860 FLEXCAN_CTRL_PSEG2(bt
->phase_seg2
- 1) |
861 FLEXCAN_CTRL_RJW(bt
->sjw
- 1) |
862 FLEXCAN_CTRL_PROPSEG(bt
->prop_seg
- 1);
864 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LOOPBACK
)
865 reg
|= FLEXCAN_CTRL_LPB
;
866 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
867 reg
|= FLEXCAN_CTRL_LOM
;
868 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
869 reg
|= FLEXCAN_CTRL_SMP
;
871 netdev_dbg(dev
, "writing ctrl=0x%08x\n", reg
);
872 flexcan_write(reg
, ®s
->ctrl
);
874 /* print chip status */
875 netdev_dbg(dev
, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__
,
876 flexcan_read(®s
->mcr
), flexcan_read(®s
->ctrl
));
879 /* flexcan_chip_start
881 * this functions is entered with clocks enabled
884 static int flexcan_chip_start(struct net_device
*dev
)
886 struct flexcan_priv
*priv
= netdev_priv(dev
);
887 struct flexcan_regs __iomem
*regs
= priv
->regs
;
888 u32 reg_mcr
, reg_ctrl
, reg_ctrl2
, reg_mecr
;
892 err
= flexcan_chip_enable(priv
);
897 err
= flexcan_chip_softreset(priv
);
899 goto out_chip_disable
;
901 flexcan_set_bittiming(dev
);
908 * only supervisor access
911 * enable individual RX masking
913 * set max mailbox number
915 reg_mcr
= flexcan_read(®s
->mcr
);
916 reg_mcr
&= ~FLEXCAN_MCR_MAXMB(0xff);
917 reg_mcr
|= FLEXCAN_MCR_FRZ
| FLEXCAN_MCR_HALT
| FLEXCAN_MCR_SUPV
|
918 FLEXCAN_MCR_WRN_EN
| FLEXCAN_MCR_SRX_DIS
| FLEXCAN_MCR_IRMQ
|
921 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
922 reg_mcr
&= ~FLEXCAN_MCR_FEN
;
923 reg_mcr
|= FLEXCAN_MCR_MAXMB(priv
->offload
.mb_last
);
925 reg_mcr
|= FLEXCAN_MCR_FEN
|
926 FLEXCAN_MCR_MAXMB(priv
->tx_mb_idx
);
928 netdev_dbg(dev
, "%s: writing mcr=0x%08x", __func__
, reg_mcr
);
929 flexcan_write(reg_mcr
, ®s
->mcr
);
933 * disable timer sync feature
935 * disable auto busoff recovery
936 * transmit lowest buffer first
938 * enable tx and rx warning interrupt
939 * enable bus off interrupt
940 * (== FLEXCAN_CTRL_ERR_STATE)
942 reg_ctrl
= flexcan_read(®s
->ctrl
);
943 reg_ctrl
&= ~FLEXCAN_CTRL_TSYN
;
944 reg_ctrl
|= FLEXCAN_CTRL_BOFF_REC
| FLEXCAN_CTRL_LBUF
|
945 FLEXCAN_CTRL_ERR_STATE
;
947 /* enable the "error interrupt" (FLEXCAN_CTRL_ERR_MSK),
948 * on most Flexcan cores, too. Otherwise we don't get
949 * any error warning or passive interrupts.
951 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_BROKEN_WERR_STATE
||
952 priv
->can
.ctrlmode
& CAN_CTRLMODE_BERR_REPORTING
)
953 reg_ctrl
|= FLEXCAN_CTRL_ERR_MSK
;
955 reg_ctrl
&= ~FLEXCAN_CTRL_ERR_MSK
;
957 /* save for later use */
958 priv
->reg_ctrl_default
= reg_ctrl
;
959 /* leave interrupts disabled for now */
960 reg_ctrl
&= ~FLEXCAN_CTRL_ERR_ALL
;
961 netdev_dbg(dev
, "%s: writing ctrl=0x%08x", __func__
, reg_ctrl
);
962 flexcan_write(reg_ctrl
, ®s
->ctrl
);
964 if ((priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_ENABLE_EACEN_RRS
)) {
965 reg_ctrl2
= flexcan_read(®s
->ctrl2
);
966 reg_ctrl2
|= FLEXCAN_CTRL2_EACEN
| FLEXCAN_CTRL2_RRS
;
967 flexcan_write(reg_ctrl2
, ®s
->ctrl2
);
970 /* clear and invalidate all mailboxes first */
971 for (i
= priv
->tx_mb_idx
; i
< ARRAY_SIZE(regs
->mb
); i
++) {
972 flexcan_write(FLEXCAN_MB_CODE_RX_INACTIVE
,
973 ®s
->mb
[i
].can_ctrl
);
976 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
977 for (i
= priv
->offload
.mb_first
; i
<= priv
->offload
.mb_last
; i
++)
978 flexcan_write(FLEXCAN_MB_CODE_RX_EMPTY
,
979 ®s
->mb
[i
].can_ctrl
);
982 /* Errata ERR005829: mark first TX mailbox as INACTIVE */
983 flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE
,
984 &priv
->tx_mb_reserved
->can_ctrl
);
986 /* mark TX mailbox as INACTIVE */
987 flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE
,
988 &priv
->tx_mb
->can_ctrl
);
990 /* acceptance mask/acceptance code (accept everything) */
991 flexcan_write(0x0, ®s
->rxgmask
);
992 flexcan_write(0x0, ®s
->rx14mask
);
993 flexcan_write(0x0, ®s
->rx15mask
);
995 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_DISABLE_RXFG
)
996 flexcan_write(0x0, ®s
->rxfgmask
);
998 /* clear acceptance filters */
999 for (i
= 0; i
< ARRAY_SIZE(regs
->mb
); i
++)
1000 flexcan_write(0, ®s
->rximr
[i
]);
1002 /* On Vybrid, disable memory error detection interrupts
1004 * This also works around errata e5295 which generates
1005 * false positive memory errors and put the device in
1008 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_DISABLE_MECR
) {
1009 /* Follow the protocol as described in "Detection
1010 * and Correction of Memory Errors" to write to
1013 reg_ctrl2
= flexcan_read(®s
->ctrl2
);
1014 reg_ctrl2
|= FLEXCAN_CTRL2_ECRWRE
;
1015 flexcan_write(reg_ctrl2
, ®s
->ctrl2
);
1017 reg_mecr
= flexcan_read(®s
->mecr
);
1018 reg_mecr
&= ~FLEXCAN_MECR_ECRWRDIS
;
1019 flexcan_write(reg_mecr
, ®s
->mecr
);
1020 reg_mecr
&= ~(FLEXCAN_MECR_NCEFAFRZ
| FLEXCAN_MECR_HANCEI_MSK
|
1021 FLEXCAN_MECR_FANCEI_MSK
);
1022 flexcan_write(reg_mecr
, ®s
->mecr
);
1025 err
= flexcan_transceiver_enable(priv
);
1027 goto out_chip_disable
;
1029 /* synchronize with the can bus */
1030 err
= flexcan_chip_unfreeze(priv
);
1032 goto out_transceiver_disable
;
1034 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
1036 /* enable interrupts atomically */
1037 disable_irq(dev
->irq
);
1038 flexcan_write(priv
->reg_ctrl_default
, ®s
->ctrl
);
1039 flexcan_write(priv
->reg_imask1_default
, ®s
->imask1
);
1040 flexcan_write(priv
->reg_imask2_default
, ®s
->imask2
);
1041 enable_irq(dev
->irq
);
1043 /* print chip status */
1044 netdev_dbg(dev
, "%s: reading mcr=0x%08x ctrl=0x%08x\n", __func__
,
1045 flexcan_read(®s
->mcr
), flexcan_read(®s
->ctrl
));
1049 out_transceiver_disable
:
1050 flexcan_transceiver_disable(priv
);
1052 flexcan_chip_disable(priv
);
1056 /* flexcan_chip_stop
1058 * this functions is entered with clocks enabled
1060 static void flexcan_chip_stop(struct net_device
*dev
)
1062 struct flexcan_priv
*priv
= netdev_priv(dev
);
1063 struct flexcan_regs __iomem
*regs
= priv
->regs
;
1065 /* freeze + disable module */
1066 flexcan_chip_freeze(priv
);
1067 flexcan_chip_disable(priv
);
1069 /* Disable all interrupts */
1070 flexcan_write(0, ®s
->imask2
);
1071 flexcan_write(0, ®s
->imask1
);
1072 flexcan_write(priv
->reg_ctrl_default
& ~FLEXCAN_CTRL_ERR_ALL
,
1075 flexcan_transceiver_disable(priv
);
1076 priv
->can
.state
= CAN_STATE_STOPPED
;
1079 static int flexcan_open(struct net_device
*dev
)
1081 struct flexcan_priv
*priv
= netdev_priv(dev
);
1084 err
= clk_prepare_enable(priv
->clk_ipg
);
1088 err
= clk_prepare_enable(priv
->clk_per
);
1090 goto out_disable_ipg
;
1092 err
= open_candev(dev
);
1094 goto out_disable_per
;
1096 err
= request_irq(dev
->irq
, flexcan_irq
, IRQF_SHARED
, dev
->name
, dev
);
1100 /* start chip and queuing */
1101 err
= flexcan_chip_start(dev
);
1105 can_led_event(dev
, CAN_LED_EVENT_OPEN
);
1107 can_rx_offload_enable(&priv
->offload
);
1108 netif_start_queue(dev
);
1113 free_irq(dev
->irq
, dev
);
1117 clk_disable_unprepare(priv
->clk_per
);
1119 clk_disable_unprepare(priv
->clk_ipg
);
1124 static int flexcan_close(struct net_device
*dev
)
1126 struct flexcan_priv
*priv
= netdev_priv(dev
);
1128 netif_stop_queue(dev
);
1129 can_rx_offload_disable(&priv
->offload
);
1130 flexcan_chip_stop(dev
);
1132 free_irq(dev
->irq
, dev
);
1133 clk_disable_unprepare(priv
->clk_per
);
1134 clk_disable_unprepare(priv
->clk_ipg
);
1138 can_led_event(dev
, CAN_LED_EVENT_STOP
);
1143 static int flexcan_set_mode(struct net_device
*dev
, enum can_mode mode
)
1148 case CAN_MODE_START
:
1149 err
= flexcan_chip_start(dev
);
1153 netif_wake_queue(dev
);
1163 static const struct net_device_ops flexcan_netdev_ops
= {
1164 .ndo_open
= flexcan_open
,
1165 .ndo_stop
= flexcan_close
,
1166 .ndo_start_xmit
= flexcan_start_xmit
,
1167 .ndo_change_mtu
= can_change_mtu
,
1170 static int register_flexcandev(struct net_device
*dev
)
1172 struct flexcan_priv
*priv
= netdev_priv(dev
);
1173 struct flexcan_regs __iomem
*regs
= priv
->regs
;
1176 err
= clk_prepare_enable(priv
->clk_ipg
);
1180 err
= clk_prepare_enable(priv
->clk_per
);
1182 goto out_disable_ipg
;
1184 /* select "bus clock", chip must be disabled */
1185 err
= flexcan_chip_disable(priv
);
1187 goto out_disable_per
;
1188 reg
= flexcan_read(®s
->ctrl
);
1189 reg
|= FLEXCAN_CTRL_CLK_SRC
;
1190 flexcan_write(reg
, ®s
->ctrl
);
1192 err
= flexcan_chip_enable(priv
);
1194 goto out_chip_disable
;
1196 /* set freeze, halt and activate FIFO, restrict register access */
1197 reg
= flexcan_read(®s
->mcr
);
1198 reg
|= FLEXCAN_MCR_FRZ
| FLEXCAN_MCR_HALT
|
1199 FLEXCAN_MCR_FEN
| FLEXCAN_MCR_SUPV
;
1200 flexcan_write(reg
, ®s
->mcr
);
1202 /* Currently we only support newer versions of this core
1203 * featuring a RX hardware FIFO (although this driver doesn't
1204 * make use of it on some cores). Older cores, found on some
1205 * Coldfire derivates are not tested.
1207 reg
= flexcan_read(®s
->mcr
);
1208 if (!(reg
& FLEXCAN_MCR_FEN
)) {
1209 netdev_err(dev
, "Could not enable RX FIFO, unsupported core\n");
1211 goto out_chip_disable
;
1214 err
= register_candev(dev
);
1216 /* disable core and turn off clocks */
1218 flexcan_chip_disable(priv
);
1220 clk_disable_unprepare(priv
->clk_per
);
1222 clk_disable_unprepare(priv
->clk_ipg
);
1227 static void unregister_flexcandev(struct net_device
*dev
)
1229 unregister_candev(dev
);
1232 static const struct of_device_id flexcan_of_match
[] = {
1233 { .compatible
= "fsl,imx6q-flexcan", .data
= &fsl_imx6q_devtype_data
, },
1234 { .compatible
= "fsl,imx28-flexcan", .data
= &fsl_imx28_devtype_data
, },
1235 { .compatible
= "fsl,p1010-flexcan", .data
= &fsl_p1010_devtype_data
, },
1236 { .compatible
= "fsl,vf610-flexcan", .data
= &fsl_vf610_devtype_data
, },
1239 MODULE_DEVICE_TABLE(of
, flexcan_of_match
);
1241 static const struct platform_device_id flexcan_id_table
[] = {
1242 { .name
= "flexcan", .driver_data
= (kernel_ulong_t
)&fsl_p1010_devtype_data
, },
1245 MODULE_DEVICE_TABLE(platform
, flexcan_id_table
);
1247 static int flexcan_probe(struct platform_device
*pdev
)
1249 const struct of_device_id
*of_id
;
1250 const struct flexcan_devtype_data
*devtype_data
;
1251 struct net_device
*dev
;
1252 struct flexcan_priv
*priv
;
1253 struct regulator
*reg_xceiver
;
1254 struct resource
*mem
;
1255 struct clk
*clk_ipg
= NULL
, *clk_per
= NULL
;
1256 struct flexcan_regs __iomem
*regs
;
1260 reg_xceiver
= devm_regulator_get(&pdev
->dev
, "xceiver");
1261 if (PTR_ERR(reg_xceiver
) == -EPROBE_DEFER
)
1262 return -EPROBE_DEFER
;
1263 else if (IS_ERR(reg_xceiver
))
1266 if (pdev
->dev
.of_node
)
1267 of_property_read_u32(pdev
->dev
.of_node
,
1268 "clock-frequency", &clock_freq
);
1271 clk_ipg
= devm_clk_get(&pdev
->dev
, "ipg");
1272 if (IS_ERR(clk_ipg
)) {
1273 dev_err(&pdev
->dev
, "no ipg clock defined\n");
1274 return PTR_ERR(clk_ipg
);
1277 clk_per
= devm_clk_get(&pdev
->dev
, "per");
1278 if (IS_ERR(clk_per
)) {
1279 dev_err(&pdev
->dev
, "no per clock defined\n");
1280 return PTR_ERR(clk_per
);
1282 clock_freq
= clk_get_rate(clk_per
);
1285 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1286 irq
= platform_get_irq(pdev
, 0);
1290 regs
= devm_ioremap_resource(&pdev
->dev
, mem
);
1292 return PTR_ERR(regs
);
1294 of_id
= of_match_device(flexcan_of_match
, &pdev
->dev
);
1296 devtype_data
= of_id
->data
;
1297 } else if (platform_get_device_id(pdev
)->driver_data
) {
1298 devtype_data
= (struct flexcan_devtype_data
*)
1299 platform_get_device_id(pdev
)->driver_data
;
1304 dev
= alloc_candev(sizeof(struct flexcan_priv
), 1);
1308 platform_set_drvdata(pdev
, dev
);
1309 SET_NETDEV_DEV(dev
, &pdev
->dev
);
1311 dev
->netdev_ops
= &flexcan_netdev_ops
;
1313 dev
->flags
|= IFF_ECHO
;
1315 priv
= netdev_priv(dev
);
1316 priv
->can
.clock
.freq
= clock_freq
;
1317 priv
->can
.bittiming_const
= &flexcan_bittiming_const
;
1318 priv
->can
.do_set_mode
= flexcan_set_mode
;
1319 priv
->can
.do_get_berr_counter
= flexcan_get_berr_counter
;
1320 priv
->can
.ctrlmode_supported
= CAN_CTRLMODE_LOOPBACK
|
1321 CAN_CTRLMODE_LISTENONLY
| CAN_CTRLMODE_3_SAMPLES
|
1322 CAN_CTRLMODE_BERR_REPORTING
;
1324 priv
->clk_ipg
= clk_ipg
;
1325 priv
->clk_per
= clk_per
;
1326 priv
->devtype_data
= devtype_data
;
1327 priv
->reg_xceiver
= reg_xceiver
;
1329 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
1330 priv
->tx_mb_idx
= FLEXCAN_TX_MB_OFF_TIMESTAMP
;
1331 priv
->tx_mb_reserved
= ®s
->mb
[FLEXCAN_TX_MB_RESERVED_OFF_TIMESTAMP
];
1333 priv
->tx_mb_idx
= FLEXCAN_TX_MB_OFF_FIFO
;
1334 priv
->tx_mb_reserved
= ®s
->mb
[FLEXCAN_TX_MB_RESERVED_OFF_FIFO
];
1336 priv
->tx_mb
= ®s
->mb
[priv
->tx_mb_idx
];
1338 priv
->reg_imask1_default
= FLEXCAN_IFLAG_MB(priv
->tx_mb_idx
);
1339 priv
->reg_imask2_default
= 0;
1341 priv
->offload
.mailbox_read
= flexcan_mailbox_read
;
1343 if (priv
->devtype_data
->quirks
& FLEXCAN_QUIRK_USE_OFF_TIMESTAMP
) {
1346 priv
->offload
.mb_first
= FLEXCAN_RX_MB_OFF_TIMESTAMP_FIRST
;
1347 priv
->offload
.mb_last
= FLEXCAN_RX_MB_OFF_TIMESTAMP_LAST
;
1349 imask
= GENMASK_ULL(priv
->offload
.mb_last
, priv
->offload
.mb_first
);
1350 priv
->reg_imask1_default
|= imask
;
1351 priv
->reg_imask2_default
|= imask
>> 32;
1353 err
= can_rx_offload_add_timestamp(dev
, &priv
->offload
);
1355 priv
->reg_imask1_default
|= FLEXCAN_IFLAG_RX_FIFO_OVERFLOW
|
1356 FLEXCAN_IFLAG_RX_FIFO_AVAILABLE
;
1357 err
= can_rx_offload_add_fifo(dev
, &priv
->offload
, FLEXCAN_NAPI_WEIGHT
);
1360 goto failed_offload
;
1362 err
= register_flexcandev(dev
);
1364 dev_err(&pdev
->dev
, "registering netdev failed\n");
1365 goto failed_register
;
1368 devm_can_led_init(dev
);
1370 dev_info(&pdev
->dev
, "device registered (reg_base=%p, irq=%d)\n",
1371 priv
->regs
, dev
->irq
);
1381 static int flexcan_remove(struct platform_device
*pdev
)
1383 struct net_device
*dev
= platform_get_drvdata(pdev
);
1384 struct flexcan_priv
*priv
= netdev_priv(dev
);
1386 unregister_flexcandev(dev
);
1387 can_rx_offload_del(&priv
->offload
);
1393 static int __maybe_unused
flexcan_suspend(struct device
*device
)
1395 struct net_device
*dev
= dev_get_drvdata(device
);
1396 struct flexcan_priv
*priv
= netdev_priv(dev
);
1399 if (netif_running(dev
)) {
1400 err
= flexcan_chip_disable(priv
);
1403 netif_stop_queue(dev
);
1404 netif_device_detach(dev
);
1406 priv
->can
.state
= CAN_STATE_SLEEPING
;
1411 static int __maybe_unused
flexcan_resume(struct device
*device
)
1413 struct net_device
*dev
= dev_get_drvdata(device
);
1414 struct flexcan_priv
*priv
= netdev_priv(dev
);
1417 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
1418 if (netif_running(dev
)) {
1419 netif_device_attach(dev
);
1420 netif_start_queue(dev
);
1421 err
= flexcan_chip_enable(priv
);
1428 static SIMPLE_DEV_PM_OPS(flexcan_pm_ops
, flexcan_suspend
, flexcan_resume
);
1430 static struct platform_driver flexcan_driver
= {
1433 .pm
= &flexcan_pm_ops
,
1434 .of_match_table
= flexcan_of_match
,
1436 .probe
= flexcan_probe
,
1437 .remove
= flexcan_remove
,
1438 .id_table
= flexcan_id_table
,
1441 module_platform_driver(flexcan_driver
);
1443 MODULE_AUTHOR("Sascha Hauer <kernel@pengutronix.de>, "
1444 "Marc Kleine-Budde <kernel@pengutronix.de>");
1445 MODULE_LICENSE("GPL v2");
1446 MODULE_DESCRIPTION("CAN port driver for flexcan based chip");