1 From 3ed707fde8a33f2b888f75ac2f5e0a98e7774dad Mon Sep 17 00:00:00 2001
2 From: Biwen Li <biwen.li@nxp.com>
3 Date: Tue, 30 Oct 2018 18:26:27 +0800
4 Subject: [PATCH 26/40] flexcan: support layerscape
5 This is an integrated patch of flexcan for layerscape
7 Signed-off-by: Bhupesh Sharma <bhupesh.sharma@freescale.com>
8 Signed-off-by: Guanhua Gao <guanhua.gao@nxp.com>
9 Signed-off-by: Pankaj Bansal <pankaj.bansal@nxp.com>
10 Signed-off-by: Sakar Arora <Sakar.Arora@freescale.com>
11 Signed-off-by: Biwen Li <biwen.li@nxp.com>
13 drivers/net/can/flexcan.c | 240 ++++++++++++++++++++++----------------
14 1 file changed, 138 insertions(+), 102 deletions(-)
16 --- a/drivers/net/can/flexcan.c
17 +++ b/drivers/net/can/flexcan.c
19 * MX53 FlexCAN2 03.00.00.00 yes no no no no
20 * MX6s FlexCAN3 10.00.12.00 yes yes no no yes
21 * VF610 FlexCAN3 ? no yes no yes yes?
22 + * LS1021A FlexCAN2 03.00.04.00 no yes no yes
24 * Some SOCs do not have the RX_WARN & TX_WARN interrupt line connected.
26 @@ -279,6 +280,10 @@ struct flexcan_priv {
28 const struct flexcan_devtype_data *devtype_data;
29 struct regulator *reg_xceiver;
31 + /* Read and Write APIs */
32 + u32 (*read)(void __iomem *addr);
33 + void (*write)(u32 val, void __iomem *addr);
36 static const struct flexcan_devtype_data fsl_p1010_devtype_data = {
37 @@ -301,6 +306,11 @@ static const struct flexcan_devtype_data
38 FLEXCAN_QUIRK_BROKEN_PERR_STATE,
41 +static const struct flexcan_devtype_data fsl_ls1021a_r2_devtype_data = {
42 + .quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS |
43 + FLEXCAN_QUIRK_DISABLE_MECR | FLEXCAN_QUIRK_USE_OFF_TIMESTAMP,
46 static const struct can_bittiming_const flexcan_bittiming_const = {
49 @@ -313,39 +323,45 @@ static const struct can_bittiming_const
53 -/* Abstract off the read/write for arm versus ppc. This
54 - * assumes that PPC uses big-endian registers and everything
55 - * else uses little-endian registers, independent of CPU
57 +/* FlexCAN module is essentially modelled as a little-endian IP in most
58 + * SoCs, i.e the registers as well as the message buffer areas are
59 + * implemented in a little-endian fashion.
61 + * However there are some SoCs (e.g. LS1021A) which implement the FlexCAN
62 + * module in a big-endian fashion (i.e the registers as well as the
63 + * message buffer areas are implemented in a big-endian way).
65 + * In addition, the FlexCAN module can be found on SoCs having ARM or
66 + * PPC cores. So, we need to abstract off the register read/write
67 + * functions, ensuring that these cater to all the combinations of module
68 + * endianness and underlying CPU endianness.
70 -#if defined(CONFIG_PPC)
71 -static inline u32 flexcan_read(void __iomem *addr)
72 +static inline u32 flexcan_read_be(void __iomem *addr)
74 - return in_be32(addr);
75 + return ioread32be(addr);
78 -static inline void flexcan_write(u32 val, void __iomem *addr)
79 +static inline void flexcan_write_be(u32 val, void __iomem *addr)
81 - out_be32(addr, val);
82 + iowrite32be(val, addr);
85 -static inline u32 flexcan_read(void __iomem *addr)
87 +static inline u32 flexcan_read_le(void __iomem *addr)
90 + return ioread32(addr);
93 -static inline void flexcan_write(u32 val, void __iomem *addr)
94 +static inline void flexcan_write_le(u32 val, void __iomem *addr)
97 + iowrite32(val, addr);
101 static inline void flexcan_error_irq_enable(const struct flexcan_priv *priv)
103 struct flexcan_regs __iomem *regs = priv->regs;
104 u32 reg_ctrl = (priv->reg_ctrl_default | FLEXCAN_CTRL_ERR_MSK);
106 - flexcan_write(reg_ctrl, ®s->ctrl);
107 + priv->write(reg_ctrl, ®s->ctrl);
110 static inline void flexcan_error_irq_disable(const struct flexcan_priv *priv)
111 @@ -353,7 +369,7 @@ static inline void flexcan_error_irq_dis
112 struct flexcan_regs __iomem *regs = priv->regs;
113 u32 reg_ctrl = (priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_MSK);
115 - flexcan_write(reg_ctrl, ®s->ctrl);
116 + priv->write(reg_ctrl, ®s->ctrl);
119 static inline int flexcan_transceiver_enable(const struct flexcan_priv *priv)
120 @@ -378,14 +394,14 @@ static int flexcan_chip_enable(struct fl
121 unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;
124 - reg = flexcan_read(®s->mcr);
125 + reg = priv->read(®s->mcr);
126 reg &= ~FLEXCAN_MCR_MDIS;
127 - flexcan_write(reg, ®s->mcr);
128 + priv->write(reg, ®s->mcr);
130 - while (timeout-- && (flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK))
131 + while (timeout-- && (priv->read(®s->mcr) & FLEXCAN_MCR_LPM_ACK))
134 - if (flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK)
135 + if (priv->read(®s->mcr) & FLEXCAN_MCR_LPM_ACK)
139 @@ -397,14 +413,14 @@ static int flexcan_chip_disable(struct f
140 unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;
143 - reg = flexcan_read(®s->mcr);
144 + reg = priv->read(®s->mcr);
145 reg |= FLEXCAN_MCR_MDIS;
146 - flexcan_write(reg, ®s->mcr);
147 + priv->write(reg, ®s->mcr);
149 - while (timeout-- && !(flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK))
150 + while (timeout-- && !(priv->read(®s->mcr) & FLEXCAN_MCR_LPM_ACK))
153 - if (!(flexcan_read(®s->mcr) & FLEXCAN_MCR_LPM_ACK))
154 + if (!(priv->read(®s->mcr) & FLEXCAN_MCR_LPM_ACK))
158 @@ -416,14 +432,14 @@ static int flexcan_chip_freeze(struct fl
159 unsigned int timeout = 1000 * 1000 * 10 / priv->can.bittiming.bitrate;
162 - reg = flexcan_read(®s->mcr);
163 + reg = priv->read(®s->mcr);
164 reg |= FLEXCAN_MCR_HALT;
165 - flexcan_write(reg, ®s->mcr);
166 + priv->write(reg, ®s->mcr);
168 - while (timeout-- && !(flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK))
169 + while (timeout-- && !(priv->read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK))
172 - if (!(flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK))
173 + if (!(priv->read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK))
177 @@ -435,14 +451,14 @@ static int flexcan_chip_unfreeze(struct
178 unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;
181 - reg = flexcan_read(®s->mcr);
182 + reg = priv->read(®s->mcr);
183 reg &= ~FLEXCAN_MCR_HALT;
184 - flexcan_write(reg, ®s->mcr);
185 + priv->write(reg, ®s->mcr);
187 - while (timeout-- && (flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK))
188 + while (timeout-- && (priv->read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK))
191 - if (flexcan_read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK)
192 + if (priv->read(®s->mcr) & FLEXCAN_MCR_FRZ_ACK)
196 @@ -453,11 +469,11 @@ static int flexcan_chip_softreset(struct
197 struct flexcan_regs __iomem *regs = priv->regs;
198 unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;
200 - flexcan_write(FLEXCAN_MCR_SOFTRST, ®s->mcr);
201 - while (timeout-- && (flexcan_read(®s->mcr) & FLEXCAN_MCR_SOFTRST))
202 + priv->write(FLEXCAN_MCR_SOFTRST, ®s->mcr);
203 + while (timeout-- && (priv->read(®s->mcr) & FLEXCAN_MCR_SOFTRST))
206 - if (flexcan_read(®s->mcr) & FLEXCAN_MCR_SOFTRST)
207 + if (priv->read(®s->mcr) & FLEXCAN_MCR_SOFTRST)
211 @@ -468,7 +484,7 @@ static int __flexcan_get_berr_counter(co
213 const struct flexcan_priv *priv = netdev_priv(dev);
214 struct flexcan_regs __iomem *regs = priv->regs;
215 - u32 reg = flexcan_read(®s->ecr);
216 + u32 reg = priv->read(®s->ecr);
218 bec->txerr = (reg >> 0) & 0xff;
219 bec->rxerr = (reg >> 8) & 0xff;
220 @@ -524,24 +540,24 @@ static int flexcan_start_xmit(struct sk_
222 if (cf->can_dlc > 0) {
223 data = be32_to_cpup((__be32 *)&cf->data[0]);
224 - flexcan_write(data, &priv->tx_mb->data[0]);
225 + priv->write(data, &priv->tx_mb->data[0]);
227 if (cf->can_dlc > 4) {
228 data = be32_to_cpup((__be32 *)&cf->data[4]);
229 - flexcan_write(data, &priv->tx_mb->data[1]);
230 + priv->write(data, &priv->tx_mb->data[1]);
233 can_put_echo_skb(skb, dev, 0);
235 - flexcan_write(can_id, &priv->tx_mb->can_id);
236 - flexcan_write(ctrl, &priv->tx_mb->can_ctrl);
237 + priv->write(can_id, &priv->tx_mb->can_id);
238 + priv->write(ctrl, &priv->tx_mb->can_ctrl);
240 /* Errata ERR005829 step8:
241 * Write twice INACTIVE(0x8) code to first MB.
243 - flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
244 + priv->write(FLEXCAN_MB_CODE_TX_INACTIVE,
245 &priv->tx_mb_reserved->can_ctrl);
246 - flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
247 + priv->write(FLEXCAN_MB_CODE_TX_INACTIVE,
248 &priv->tx_mb_reserved->can_ctrl);
251 @@ -660,7 +676,7 @@ static unsigned int flexcan_mailbox_read
255 - reg_ctrl = flexcan_read(&mb->can_ctrl);
256 + reg_ctrl = priv->read(&mb->can_ctrl);
257 } while (reg_ctrl & FLEXCAN_MB_CODE_RX_BUSY_BIT);
259 /* is this MB empty? */
260 @@ -675,17 +691,17 @@ static unsigned int flexcan_mailbox_read
261 offload->dev->stats.rx_errors++;
264 - reg_iflag1 = flexcan_read(®s->iflag1);
265 + reg_iflag1 = priv->read(®s->iflag1);
266 if (!(reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE))
269 - reg_ctrl = flexcan_read(&mb->can_ctrl);
270 + reg_ctrl = priv->read(&mb->can_ctrl);
273 /* increase timstamp to full 32 bit */
274 *timestamp = reg_ctrl << 16;
276 - reg_id = flexcan_read(&mb->can_id);
277 + reg_id = priv->read(&mb->can_id);
278 if (reg_ctrl & FLEXCAN_MB_CNT_IDE)
279 cf->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG;
281 @@ -695,19 +711,19 @@ static unsigned int flexcan_mailbox_read
282 cf->can_id |= CAN_RTR_FLAG;
283 cf->can_dlc = get_can_dlc((reg_ctrl >> 16) & 0xf);
285 - *(__be32 *)(cf->data + 0) = cpu_to_be32(flexcan_read(&mb->data[0]));
286 - *(__be32 *)(cf->data + 4) = cpu_to_be32(flexcan_read(&mb->data[1]));
287 + *(__be32 *)(cf->data + 0) = cpu_to_be32(priv->read(&mb->data[0]));
288 + *(__be32 *)(cf->data + 4) = cpu_to_be32(priv->read(&mb->data[1]));
291 if (priv->devtype_data->quirks & FLEXCAN_QUIRK_USE_OFF_TIMESTAMP) {
294 - flexcan_write(BIT(n), ®s->iflag1);
295 + priv->write(BIT(n), ®s->iflag1);
297 - flexcan_write(BIT(n - 32), ®s->iflag2);
298 + priv->write(BIT(n - 32), ®s->iflag2);
300 - flexcan_write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, ®s->iflag1);
301 - flexcan_read(®s->timer);
302 + priv->write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, ®s->iflag1);
303 + priv->read(®s->timer);
307 @@ -719,8 +735,8 @@ static inline u64 flexcan_read_reg_iflag
308 struct flexcan_regs __iomem *regs = priv->regs;
311 - iflag2 = flexcan_read(®s->iflag2) & priv->reg_imask2_default;
312 - iflag1 = flexcan_read(®s->iflag1) & priv->reg_imask1_default &
313 + iflag2 = priv->read(®s->iflag2) & priv->reg_imask2_default;
314 + iflag1 = priv->read(®s->iflag1) & priv->reg_imask1_default &
315 ~FLEXCAN_IFLAG_MB(priv->tx_mb_idx);
317 return (u64)iflag2 << 32 | iflag1;
318 @@ -736,7 +752,7 @@ static irqreturn_t flexcan_irq(int irq,
319 u32 reg_iflag1, reg_esr;
320 enum can_state last_state = priv->can.state;
322 - reg_iflag1 = flexcan_read(®s->iflag1);
323 + reg_iflag1 = priv->read(®s->iflag1);
325 /* reception interrupt */
326 if (priv->devtype_data->quirks & FLEXCAN_QUIRK_USE_OFF_TIMESTAMP) {
327 @@ -759,7 +775,8 @@ static irqreturn_t flexcan_irq(int irq,
328 /* FIFO overflow interrupt */
329 if (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_OVERFLOW) {
330 handled = IRQ_HANDLED;
331 - flexcan_write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW, ®s->iflag1);
332 + priv->write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW,
334 dev->stats.rx_over_errors++;
335 dev->stats.rx_errors++;
337 @@ -773,18 +790,18 @@ static irqreturn_t flexcan_irq(int irq,
338 can_led_event(dev, CAN_LED_EVENT_TX);
340 /* after sending a RTR frame MB is in RX mode */
341 - flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
342 - &priv->tx_mb->can_ctrl);
343 - flexcan_write(FLEXCAN_IFLAG_MB(priv->tx_mb_idx), ®s->iflag1);
344 + priv->write(FLEXCAN_MB_CODE_TX_INACTIVE,
345 + &priv->tx_mb->can_ctrl);
346 + priv->write(FLEXCAN_IFLAG_MB(priv->tx_mb_idx), ®s->iflag1);
347 netif_wake_queue(dev);
350 - reg_esr = flexcan_read(®s->esr);
351 + reg_esr = priv->read(®s->esr);
353 /* ACK all bus error and state change IRQ sources */
354 if (reg_esr & FLEXCAN_ESR_ALL_INT) {
355 handled = IRQ_HANDLED;
356 - flexcan_write(reg_esr & FLEXCAN_ESR_ALL_INT, ®s->esr);
357 + priv->write(reg_esr & FLEXCAN_ESR_ALL_INT, ®s->esr);
360 /* state change interrupt or broken error state quirk fix is enabled */
361 @@ -846,7 +863,7 @@ static void flexcan_set_bittiming(struct
362 struct flexcan_regs __iomem *regs = priv->regs;
365 - reg = flexcan_read(®s->ctrl);
366 + reg = priv->read(®s->ctrl);
367 reg &= ~(FLEXCAN_CTRL_PRESDIV(0xff) |
368 FLEXCAN_CTRL_RJW(0x3) |
369 FLEXCAN_CTRL_PSEG1(0x7) |
370 @@ -870,11 +887,11 @@ static void flexcan_set_bittiming(struct
371 reg |= FLEXCAN_CTRL_SMP;
373 netdev_dbg(dev, "writing ctrl=0x%08x\n", reg);
374 - flexcan_write(reg, ®s->ctrl);
375 + priv->write(reg, ®s->ctrl);
377 /* print chip status */
378 netdev_dbg(dev, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__,
379 - flexcan_read(®s->mcr), flexcan_read(®s->ctrl));
380 + priv->read(®s->mcr), priv->read(®s->ctrl));
383 /* flexcan_chip_start
384 @@ -913,7 +930,7 @@ static int flexcan_chip_start(struct net
386 * set max mailbox number
388 - reg_mcr = flexcan_read(®s->mcr);
389 + reg_mcr = priv->read(®s->mcr);
390 reg_mcr &= ~FLEXCAN_MCR_MAXMB(0xff);
391 reg_mcr |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT | FLEXCAN_MCR_SUPV |
392 FLEXCAN_MCR_WRN_EN | FLEXCAN_MCR_SRX_DIS | FLEXCAN_MCR_IRMQ |
393 @@ -927,7 +944,7 @@ static int flexcan_chip_start(struct net
394 FLEXCAN_MCR_MAXMB(priv->tx_mb_idx);
396 netdev_dbg(dev, "%s: writing mcr=0x%08x", __func__, reg_mcr);
397 - flexcan_write(reg_mcr, ®s->mcr);
398 + priv->write(reg_mcr, ®s->mcr);
402 @@ -940,7 +957,7 @@ static int flexcan_chip_start(struct net
403 * enable bus off interrupt
404 * (== FLEXCAN_CTRL_ERR_STATE)
406 - reg_ctrl = flexcan_read(®s->ctrl);
407 + reg_ctrl = priv->read(®s->ctrl);
408 reg_ctrl &= ~FLEXCAN_CTRL_TSYN;
409 reg_ctrl |= FLEXCAN_CTRL_BOFF_REC | FLEXCAN_CTRL_LBUF |
410 FLEXCAN_CTRL_ERR_STATE;
411 @@ -960,45 +977,45 @@ static int flexcan_chip_start(struct net
412 /* leave interrupts disabled for now */
413 reg_ctrl &= ~FLEXCAN_CTRL_ERR_ALL;
414 netdev_dbg(dev, "%s: writing ctrl=0x%08x", __func__, reg_ctrl);
415 - flexcan_write(reg_ctrl, ®s->ctrl);
416 + priv->write(reg_ctrl, ®s->ctrl);
418 if ((priv->devtype_data->quirks & FLEXCAN_QUIRK_ENABLE_EACEN_RRS)) {
419 - reg_ctrl2 = flexcan_read(®s->ctrl2);
420 + reg_ctrl2 = priv->read(®s->ctrl2);
421 reg_ctrl2 |= FLEXCAN_CTRL2_EACEN | FLEXCAN_CTRL2_RRS;
422 - flexcan_write(reg_ctrl2, ®s->ctrl2);
423 + priv->write(reg_ctrl2, ®s->ctrl2);
426 /* clear and invalidate all mailboxes first */
427 for (i = priv->tx_mb_idx; i < ARRAY_SIZE(regs->mb); i++) {
428 - flexcan_write(FLEXCAN_MB_CODE_RX_INACTIVE,
429 - ®s->mb[i].can_ctrl);
430 + priv->write(FLEXCAN_MB_CODE_RX_INACTIVE,
431 + ®s->mb[i].can_ctrl);
434 if (priv->devtype_data->quirks & FLEXCAN_QUIRK_USE_OFF_TIMESTAMP) {
435 for (i = priv->offload.mb_first; i <= priv->offload.mb_last; i++)
436 - flexcan_write(FLEXCAN_MB_CODE_RX_EMPTY,
437 - ®s->mb[i].can_ctrl);
438 + priv->write(FLEXCAN_MB_CODE_RX_EMPTY,
439 + ®s->mb[i].can_ctrl);
442 /* Errata ERR005829: mark first TX mailbox as INACTIVE */
443 - flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
444 - &priv->tx_mb_reserved->can_ctrl);
445 + priv->write(FLEXCAN_MB_CODE_TX_INACTIVE,
446 + &priv->tx_mb_reserved->can_ctrl);
448 /* mark TX mailbox as INACTIVE */
449 - flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
450 - &priv->tx_mb->can_ctrl);
451 + priv->write(FLEXCAN_MB_CODE_TX_INACTIVE,
452 + &priv->tx_mb->can_ctrl);
454 /* acceptance mask/acceptance code (accept everything) */
455 - flexcan_write(0x0, ®s->rxgmask);
456 - flexcan_write(0x0, ®s->rx14mask);
457 - flexcan_write(0x0, ®s->rx15mask);
458 + priv->write(0x0, ®s->rxgmask);
459 + priv->write(0x0, ®s->rx14mask);
460 + priv->write(0x0, ®s->rx15mask);
462 if (priv->devtype_data->quirks & FLEXCAN_QUIRK_DISABLE_RXFG)
463 - flexcan_write(0x0, ®s->rxfgmask);
464 + priv->write(0x0, ®s->rxfgmask);
466 /* clear acceptance filters */
467 for (i = 0; i < ARRAY_SIZE(regs->mb); i++)
468 - flexcan_write(0, ®s->rximr[i]);
469 + priv->write(0, ®s->rximr[i]);
471 /* On Vybrid, disable memory error detection interrupts
473 @@ -1011,17 +1028,17 @@ static int flexcan_chip_start(struct net
474 * and Correction of Memory Errors" to write to
477 - reg_ctrl2 = flexcan_read(®s->ctrl2);
478 + reg_ctrl2 = priv->read(®s->ctrl2);
479 reg_ctrl2 |= FLEXCAN_CTRL2_ECRWRE;
480 - flexcan_write(reg_ctrl2, ®s->ctrl2);
481 + priv->write(reg_ctrl2, ®s->ctrl2);
483 - reg_mecr = flexcan_read(®s->mecr);
484 + reg_mecr = priv->read(®s->mecr);
485 reg_mecr &= ~FLEXCAN_MECR_ECRWRDIS;
486 - flexcan_write(reg_mecr, ®s->mecr);
487 + priv->write(reg_mecr, ®s->mecr);
488 reg_mecr |= FLEXCAN_MECR_ECCDIS;
489 reg_mecr &= ~(FLEXCAN_MECR_NCEFAFRZ | FLEXCAN_MECR_HANCEI_MSK |
490 FLEXCAN_MECR_FANCEI_MSK);
491 - flexcan_write(reg_mecr, ®s->mecr);
492 + priv->write(reg_mecr, ®s->mecr);
495 err = flexcan_transceiver_enable(priv);
496 @@ -1037,14 +1054,14 @@ static int flexcan_chip_start(struct net
498 /* enable interrupts atomically */
499 disable_irq(dev->irq);
500 - flexcan_write(priv->reg_ctrl_default, ®s->ctrl);
501 - flexcan_write(priv->reg_imask1_default, ®s->imask1);
502 - flexcan_write(priv->reg_imask2_default, ®s->imask2);
503 + priv->write(priv->reg_ctrl_default, ®s->ctrl);
504 + priv->write(priv->reg_imask1_default, ®s->imask1);
505 + priv->write(priv->reg_imask2_default, ®s->imask2);
506 enable_irq(dev->irq);
508 /* print chip status */
509 netdev_dbg(dev, "%s: reading mcr=0x%08x ctrl=0x%08x\n", __func__,
510 - flexcan_read(®s->mcr), flexcan_read(®s->ctrl));
511 + priv->read(®s->mcr), priv->read(®s->ctrl));
515 @@ -1069,10 +1086,10 @@ static void flexcan_chip_stop(struct net
516 flexcan_chip_disable(priv);
518 /* Disable all interrupts */
519 - flexcan_write(0, ®s->imask2);
520 - flexcan_write(0, ®s->imask1);
521 - flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL,
523 + priv->write(0, ®s->imask2);
524 + priv->write(0, ®s->imask1);
525 + priv->write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL,
528 flexcan_transceiver_disable(priv);
529 priv->can.state = CAN_STATE_STOPPED;
530 @@ -1187,26 +1204,26 @@ static int register_flexcandev(struct ne
531 err = flexcan_chip_disable(priv);
533 goto out_disable_per;
534 - reg = flexcan_read(®s->ctrl);
535 + reg = priv->read(®s->ctrl);
536 reg |= FLEXCAN_CTRL_CLK_SRC;
537 - flexcan_write(reg, ®s->ctrl);
538 + priv->write(reg, ®s->ctrl);
540 err = flexcan_chip_enable(priv);
542 goto out_chip_disable;
544 /* set freeze, halt and activate FIFO, restrict register access */
545 - reg = flexcan_read(®s->mcr);
546 + reg = priv->read(®s->mcr);
547 reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT |
548 FLEXCAN_MCR_FEN | FLEXCAN_MCR_SUPV;
549 - flexcan_write(reg, ®s->mcr);
550 + priv->write(reg, ®s->mcr);
552 /* Currently we only support newer versions of this core
553 * featuring a RX hardware FIFO (although this driver doesn't
554 * make use of it on some cores). Older cores, found on some
555 * Coldfire derivates are not tested.
557 - reg = flexcan_read(®s->mcr);
558 + reg = priv->read(®s->mcr);
559 if (!(reg & FLEXCAN_MCR_FEN)) {
560 netdev_err(dev, "Could not enable RX FIFO, unsupported core\n");
562 @@ -1234,8 +1251,12 @@ static void unregister_flexcandev(struct
563 static const struct of_device_id flexcan_of_match[] = {
564 { .compatible = "fsl,imx6q-flexcan", .data = &fsl_imx6q_devtype_data, },
565 { .compatible = "fsl,imx28-flexcan", .data = &fsl_imx28_devtype_data, },
566 + { .compatible = "fsl,imx53-flexcan", .data = &fsl_p1010_devtype_data, },
567 + { .compatible = "fsl,imx35-flexcan", .data = &fsl_p1010_devtype_data, },
568 + { .compatible = "fsl,imx25-flexcan", .data = &fsl_p1010_devtype_data, },
569 { .compatible = "fsl,p1010-flexcan", .data = &fsl_p1010_devtype_data, },
570 { .compatible = "fsl,vf610-flexcan", .data = &fsl_vf610_devtype_data, },
571 + { .compatible = "fsl,ls1021ar2-flexcan", .data = &fsl_ls1021a_r2_devtype_data, },
574 MODULE_DEVICE_TABLE(of, flexcan_of_match);
575 @@ -1315,6 +1336,21 @@ static int flexcan_probe(struct platform
576 dev->flags |= IFF_ECHO;
578 priv = netdev_priv(dev);
580 + if (of_property_read_bool(pdev->dev.of_node, "big-endian")) {
581 + priv->read = flexcan_read_be;
582 + priv->write = flexcan_write_be;
584 + if (of_device_is_compatible(pdev->dev.of_node,
585 + "fsl,p1010-flexcan")) {
586 + priv->read = flexcan_read_be;
587 + priv->write = flexcan_write_be;
589 + priv->read = flexcan_read_le;
590 + priv->write = flexcan_write_le;
594 priv->can.clock.freq = clock_freq;
595 priv->can.bittiming_const = &flexcan_bittiming_const;
596 priv->can.do_set_mode = flexcan_set_mode;