drivers/net/can/flexcan.c

   1 /*
   2  * flexcan.c - FLEXCAN CAN controller driver
   3  *
   4  * Copyright (c) 2005-2006 Varma Electronics Oy
   5  * Copyright (c) 2009 Sascha Hauer, Pengutronix
   6  * Copyright (c) 2010 Marc Kleine-Budde, Pengutronix
   7  *
   8  * Based on code originally by Andrey Volkov <avolkov@varma-el.com>
   9  *
  10  * LICENCE:
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License as
  13  * published by the Free Software Foundation version 2.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  */
  21
  22 #include <linux/netdevice.h>
  23 #include <linux/can.h>
  24 #include <linux/can/dev.h>
  25 #include <linux/can/error.h>
  26 #include <linux/can/platform/flexcan.h>
  27 #include <linux/clk.h>
  28 #include <linux/delay.h>
  29 #include <linux/if_arp.h>
  30 #include <linux/if_ether.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/io.h>
  33 #include <linux/kernel.h>
  34 #include <linux/list.h>
  35 #include <linux/module.h>
  36 #include <linux/of.h>
  37 #include <linux/platform_device.h>
  38
  39 #define DRV_NAME                        "flexcan"
  40
  41 /* 8 for RX fifo and 2 error handling */
  42 #define FLEXCAN_NAPI_WEIGHT             (8 + 2)
  43
  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_BCC                 BIT(16)
  61 #define FLEXCAN_MCR_LPRIO_EN            BIT(13)
  62 #define FLEXCAN_MCR_AEN                 BIT(12)
  63 #define FLEXCAN_MCR_MAXMB(x)            ((x) & 0x1f)
  64 #define FLEXCAN_MCR_IDAM_A              (0 << 8)
  65 #define FLEXCAN_MCR_IDAM_B              (1 << 8)
  66 #define FLEXCAN_MCR_IDAM_C              (2 << 8)
  67 #define FLEXCAN_MCR_IDAM_D              (3 << 8)
  68
  69 /* FLEXCAN control register (CANCTRL) bits */
  70 #define FLEXCAN_CTRL_PRESDIV(x)         (((x) & 0xff) << 24)
  71 #define FLEXCAN_CTRL_RJW(x)             (((x) & 0x03) << 22)
  72 #define FLEXCAN_CTRL_PSEG1(x)           (((x) & 0x07) << 19)
  73 #define FLEXCAN_CTRL_PSEG2(x)           (((x) & 0x07) << 16)
  74 #define FLEXCAN_CTRL_BOFF_MSK           BIT(15)
  75 #define FLEXCAN_CTRL_ERR_MSK            BIT(14)
  76 #define FLEXCAN_CTRL_CLK_SRC            BIT(13)
  77 #define FLEXCAN_CTRL_LPB                BIT(12)
  78 #define FLEXCAN_CTRL_TWRN_MSK           BIT(11)
  79 #define FLEXCAN_CTRL_RWRN_MSK           BIT(10)
  80 #define FLEXCAN_CTRL_SMP                BIT(7)
  81 #define FLEXCAN_CTRL_BOFF_REC           BIT(6)
  82 #define FLEXCAN_CTRL_TSYN               BIT(5)
  83 #define FLEXCAN_CTRL_LBUF               BIT(4)
  84 #define FLEXCAN_CTRL_LOM                BIT(3)
  85 #define FLEXCAN_CTRL_PROPSEG(x)         ((x) & 0x07)
  86 #define FLEXCAN_CTRL_ERR_BUS            (FLEXCAN_CTRL_ERR_MSK)
  87 #define FLEXCAN_CTRL_ERR_STATE \
  88         (FLEXCAN_CTRL_TWRN_MSK | FLEXCAN_CTRL_RWRN_MSK | \
  89          FLEXCAN_CTRL_BOFF_MSK)
  90 #define FLEXCAN_CTRL_ERR_ALL \
  91         (FLEXCAN_CTRL_ERR_BUS | FLEXCAN_CTRL_ERR_STATE)
  92
  93 /* FLEXCAN error and status register (ESR) bits */
  94 #define FLEXCAN_ESR_TWRN_INT            BIT(17)
  95 #define FLEXCAN_ESR_RWRN_INT            BIT(16)
  96 #define FLEXCAN_ESR_BIT1_ERR            BIT(15)
  97 #define FLEXCAN_ESR_BIT0_ERR            BIT(14)
  98 #define FLEXCAN_ESR_ACK_ERR             BIT(13)
  99 #define FLEXCAN_ESR_CRC_ERR             BIT(12)
 100 #define FLEXCAN_ESR_FRM_ERR             BIT(11)
 101 #define FLEXCAN_ESR_STF_ERR             BIT(10)
 102 #define FLEXCAN_ESR_TX_WRN              BIT(9)
 103 #define FLEXCAN_ESR_RX_WRN              BIT(8)
 104 #define FLEXCAN_ESR_IDLE                BIT(7)
 105 #define FLEXCAN_ESR_TXRX                BIT(6)
 106 #define FLEXCAN_EST_FLT_CONF_SHIFT      (4)
 107 #define FLEXCAN_ESR_FLT_CONF_MASK       (0x3 << FLEXCAN_EST_FLT_CONF_SHIFT)
 108 #define FLEXCAN_ESR_FLT_CONF_ACTIVE     (0x0 << FLEXCAN_EST_FLT_CONF_SHIFT)
 109 #define FLEXCAN_ESR_FLT_CONF_PASSIVE    (0x1 << FLEXCAN_EST_FLT_CONF_SHIFT)
 110 #define FLEXCAN_ESR_BOFF_INT            BIT(2)
 111 #define FLEXCAN_ESR_ERR_INT             BIT(1)
 112 #define FLEXCAN_ESR_WAK_INT             BIT(0)
 113 #define FLEXCAN_ESR_ERR_BUS \
 114         (FLEXCAN_ESR_BIT1_ERR | FLEXCAN_ESR_BIT0_ERR | \
 115          FLEXCAN_ESR_ACK_ERR | FLEXCAN_ESR_CRC_ERR | \
 116          FLEXCAN_ESR_FRM_ERR | FLEXCAN_ESR_STF_ERR)
 117 #define FLEXCAN_ESR_ERR_STATE \
 118         (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | FLEXCAN_ESR_BOFF_INT)
 119 #define FLEXCAN_ESR_ERR_ALL \
 120         (FLEXCAN_ESR_ERR_BUS | FLEXCAN_ESR_ERR_STATE)
 121
 122 /* FLEXCAN interrupt flag register (IFLAG) bits */
 123 /* Errata ERR005829 step7: Reserve first valid MB */
 124 #define FLEXCAN_TX_BUF_RESERVED         8
 125 #define FLEXCAN_TX_BUF_ID               9
 126 #define FLEXCAN_IFLAG_BUF(x)            BIT(x)
 127 #define FLEXCAN_IFLAG_RX_FIFO_OVERFLOW  BIT(7)
 128 #define FLEXCAN_IFLAG_RX_FIFO_WARN      BIT(6)
 129 #define FLEXCAN_IFLAG_RX_FIFO_AVAILABLE BIT(5)
 130 #define FLEXCAN_IFLAG_DEFAULT \
 131         (FLEXCAN_IFLAG_RX_FIFO_OVERFLOW | FLEXCAN_IFLAG_RX_FIFO_AVAILABLE | \
 132          FLEXCAN_IFLAG_BUF(FLEXCAN_TX_BUF_ID))
 133
 134 /* FLEXCAN message buffers */
 135 #define FLEXCAN_MB_CNT_CODE(x)          (((x) & 0xf) << 24)
 136 #define FLEXCAN_MB_CODE_RX_INACTIVE     (0x0 << 24)
 137 #define FLEXCAN_MB_CODE_RX_EMPTY        (0x4 << 24)
 138 #define FLEXCAN_MB_CODE_RX_FULL         (0x2 << 24)
 139 #define FLEXCAN_MB_CODE_RX_OVERRRUN     (0x6 << 24)
 140 #define FLEXCAN_MB_CODE_RX_RANSWER      (0xa << 24)
 141
 142 #define FLEXCAN_MB_CODE_TX_INACTIVE     (0x8 << 24)
 143 #define FLEXCAN_MB_CODE_TX_ABORT        (0x9 << 24)
 144 #define FLEXCAN_MB_CODE_TX_DATA         (0xc << 24)
 145 #define FLEXCAN_MB_CODE_TX_TANSWER      (0xe << 24)
 146
 147 #define FLEXCAN_MB_CNT_SRR              BIT(22)
 148 #define FLEXCAN_MB_CNT_IDE              BIT(21)
 149 #define FLEXCAN_MB_CNT_RTR              BIT(20)
 150 #define FLEXCAN_MB_CNT_LENGTH(x)        (((x) & 0xf) << 16)
 151 #define FLEXCAN_MB_CNT_TIMESTAMP(x)     ((x) & 0xffff)
 152
 153 #define FLEXCAN_MB_CODE_MASK            (0xf0ffffff)
 154
 155 /* Structure of the message buffer */
 156 struct flexcan_mb {
 157         u32 can_ctrl;
 158         u32 can_id;
 159         u32 data[2];
 160 };
 161
 162 /* Structure of the hardware registers */
 163 struct flexcan_regs {
 164         u32 mcr;                /* 0x00 */
 165         u32 ctrl;               /* 0x04 */
 166         u32 timer;              /* 0x08 */
 167         u32 _reserved1;         /* 0x0c */
 168         u32 rxgmask;            /* 0x10 */
 169         u32 rx14mask;           /* 0x14 */
 170         u32 rx15mask;           /* 0x18 */
 171         u32 ecr;                /* 0x1c */
 172         u32 esr;                /* 0x20 */
 173         u32 imask2;             /* 0x24 */
 174         u32 imask1;             /* 0x28 */
 175         u32 iflag2;             /* 0x2c */
 176         u32 iflag1;             /* 0x30 */
 177         u32 _reserved2[19];
 178         struct flexcan_mb cantxfg[64];
 179 };
 180
 181 struct flexcan_priv {
 182         struct can_priv can;
 183         struct net_device *dev;
 184         struct napi_struct napi;
 185
 186         void __iomem *base;
 187         u32 reg_esr;
 188         u32 reg_ctrl_default;
 189
 190         struct clk *clk;
 191         struct flexcan_platform_data *pdata;
 192 };
 193
 194 static struct can_bittiming_const flexcan_bittiming_const = {
 195         .name = DRV_NAME,
 196         .tseg1_min = 4,
 197         .tseg1_max = 16,
 198         .tseg2_min = 2,
 199         .tseg2_max = 8,
 200         .sjw_max = 4,
 201         .brp_min = 1,
 202         .brp_max = 256,
 203         .brp_inc = 1,
 204 };
 205
 206 /*
 207  * Abstract off the read/write for arm versus ppc.
 208  */
 209 #if defined(__BIG_ENDIAN)
 210 static inline u32 flexcan_read(void __iomem *addr)
 211 {
 212         return in_be32(addr);
 213 }
 214
 215 static inline void flexcan_write(u32 val, void __iomem *addr)
 216 {
 217         out_be32(addr, val);
 218 }
 219 #else
 220 static inline u32 flexcan_read(void __iomem *addr)
 221 {
 222         return readl(addr);
 223 }
 224
 225 static inline void flexcan_write(u32 val, void __iomem *addr)
 226 {
 227         writel(val, addr);
 228 }
 229 #endif
 230
 231 /*
 232  * Swtich transceiver on or off
 233  */
 234 static void flexcan_transceiver_switch(const struct flexcan_priv *priv, int on)
 235 {
 236         if (priv->pdata && priv->pdata->transceiver_switch)
 237                 priv->pdata->transceiver_switch(on);
 238 }
 239
 240 static inline int flexcan_has_and_handle_berr(const struct flexcan_priv *priv,
 241                                               u32 reg_esr)
 242 {
 243         return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) &&
 244                 (reg_esr & FLEXCAN_ESR_ERR_BUS);
 245 }
 246
 247 static inline void flexcan_chip_enable(struct flexcan_priv *priv)
 248 {
 249         struct flexcan_regs __iomem *regs = priv->base;
 250         u32 reg;
 251
 252         reg = flexcan_read(&regs->mcr);
 253         reg &= ~FLEXCAN_MCR_MDIS;
 254         flexcan_write(reg, &regs->mcr);
 255
 256         udelay(10);
 257 }
 258
 259 static inline void flexcan_chip_disable(struct flexcan_priv *priv)
 260 {
 261         struct flexcan_regs __iomem *regs = priv->base;
 262         u32 reg;
 263
 264         reg = flexcan_read(&regs->mcr);
 265         reg |= FLEXCAN_MCR_MDIS;
 266         flexcan_write(reg, &regs->mcr);
 267 }
 268
 269 static int flexcan_get_berr_counter(const struct net_device *dev,
 270                                     struct can_berr_counter *bec)
 271 {
 272         const struct flexcan_priv *priv = netdev_priv(dev);
 273         struct flexcan_regs __iomem *regs = priv->base;
 274         u32 reg = flexcan_read(&regs->ecr);
 275
 276         bec->txerr = (reg >> 0) & 0xff;
 277         bec->rxerr = (reg >> 8) & 0xff;
 278
 279         return 0;
 280 }
 281
 282 static int flexcan_start_xmit(struct sk_buff *skb, struct net_device *dev)
 283 {
 284         const struct flexcan_priv *priv = netdev_priv(dev);
 285         struct net_device_stats *stats = &dev->stats;
 286         struct flexcan_regs __iomem *regs = priv->base;
 287         struct can_frame *cf = (struct can_frame *)skb->data;
 288         u32 can_id;
 289         u32 ctrl = FLEXCAN_MB_CNT_CODE(0xc) | (cf->can_dlc << 16);
 290
 291         if (can_dropped_invalid_skb(dev, skb))
 292                 return NETDEV_TX_OK;
 293
 294         netif_stop_queue(dev);
 295
 296         if (cf->can_id & CAN_EFF_FLAG) {
 297                 can_id = cf->can_id & CAN_EFF_MASK;
 298                 ctrl |= FLEXCAN_MB_CNT_IDE | FLEXCAN_MB_CNT_SRR;
 299         } else {
 300                 can_id = (cf->can_id & CAN_SFF_MASK) << 18;
 301         }
 302
 303         if (cf->can_id & CAN_RTR_FLAG)
 304                 ctrl |= FLEXCAN_MB_CNT_RTR;
 305
 306         if (cf->can_dlc > 0) {
 307                 u32 data = be32_to_cpup((__be32 *)&cf->data[0]);
 308                 flexcan_write(data, &regs->cantxfg[FLEXCAN_TX_BUF_ID].data[0]);
 309         }
 310         if (cf->can_dlc > 3) {
 311                 u32 data = be32_to_cpup((__be32 *)&cf->data[4]);
 312                 flexcan_write(data, &regs->cantxfg[FLEXCAN_TX_BUF_ID].data[1]);
 313         }
 314
 315         flexcan_write(can_id, &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_id);
 316         flexcan_write(ctrl, &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl);
 317
 318         /* Errata ERR005829 step8:
 319          * Write twice INACTIVE(0x8) code to first MB.
 320          */
 321         flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
 322                       &regs->cantxfg[FLEXCAN_TX_BUF_RESERVED].can_ctrl);
 323         flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
 324                       &regs->cantxfg[FLEXCAN_TX_BUF_RESERVED].can_ctrl);
 325
 326         kfree_skb(skb);
 327
 328         /* tx_packets is incremented in flexcan_irq */
 329         stats->tx_bytes += cf->can_dlc;
 330
 331         return NETDEV_TX_OK;
 332 }
 333
 334 static void do_bus_err(struct net_device *dev,
 335                        struct can_frame *cf, u32 reg_esr)
 336 {
 337         struct flexcan_priv *priv = netdev_priv(dev);
 338         int rx_errors = 0, tx_errors = 0;
 339
 340         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 341
 342         if (reg_esr & FLEXCAN_ESR_BIT1_ERR) {
 343                 dev_dbg(dev->dev.parent, "BIT1_ERR irq\n");
 344                 cf->data[2] |= CAN_ERR_PROT_BIT1;
 345                 tx_errors = 1;
 346         }
 347         if (reg_esr & FLEXCAN_ESR_BIT0_ERR) {
 348                 dev_dbg(dev->dev.parent, "BIT0_ERR irq\n");
 349                 cf->data[2] |= CAN_ERR_PROT_BIT0;
 350                 tx_errors = 1;
 351         }
 352         if (reg_esr & FLEXCAN_ESR_ACK_ERR) {
 353                 dev_dbg(dev->dev.parent, "ACK_ERR irq\n");
 354                 cf->can_id |= CAN_ERR_ACK;
 355                 cf->data[3] |= CAN_ERR_PROT_LOC_ACK;
 356                 tx_errors = 1;
 357         }
 358         if (reg_esr & FLEXCAN_ESR_CRC_ERR) {
 359                 dev_dbg(dev->dev.parent, "CRC_ERR irq\n");
 360                 cf->data[2] |= CAN_ERR_PROT_BIT;
 361                 cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ;
 362                 rx_errors = 1;
 363         }
 364         if (reg_esr & FLEXCAN_ESR_FRM_ERR) {
 365                 dev_dbg(dev->dev.parent, "FRM_ERR irq\n");
 366                 cf->data[2] |= CAN_ERR_PROT_FORM;
 367                 rx_errors = 1;
 368         }
 369         if (reg_esr & FLEXCAN_ESR_STF_ERR) {
 370                 dev_dbg(dev->dev.parent, "STF_ERR irq\n");
 371                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 372                 rx_errors = 1;
 373         }
 374
 375         priv->can.can_stats.bus_error++;
 376         if (rx_errors)
 377                 dev->stats.rx_errors++;
 378         if (tx_errors)
 379                 dev->stats.tx_errors++;
 380 }
 381
 382 static int flexcan_poll_bus_err(struct net_device *dev, u32 reg_esr)
 383 {
 384         struct sk_buff *skb;
 385         struct can_frame *cf;
 386
 387         skb = alloc_can_err_skb(dev, &cf);
 388         if (unlikely(!skb))
 389                 return 0;
 390
 391         do_bus_err(dev, cf, reg_esr);
 392         netif_receive_skb(skb);
 393
 394         dev->stats.rx_packets++;
 395         dev->stats.rx_bytes += cf->can_dlc;
 396
 397         return 1;
 398 }
 399
 400 static void do_state(struct net_device *dev,
 401                      struct can_frame *cf, enum can_state new_state)
 402 {
 403         struct flexcan_priv *priv = netdev_priv(dev);
 404         struct can_berr_counter bec;
 405
 406         flexcan_get_berr_counter(dev, &bec);
 407
 408         switch (priv->can.state) {
 409         case CAN_STATE_ERROR_ACTIVE:
 410                 /*
 411                  * from: ERROR_ACTIVE
 412                  * to  : ERROR_WARNING, ERROR_PASSIVE, BUS_OFF
 413                  * =>  : there was a warning int
 414                  */
 415                 if (new_state >= CAN_STATE_ERROR_WARNING &&
 416                     new_state <= CAN_STATE_BUS_OFF) {
 417                         dev_dbg(dev->dev.parent, "Error Warning IRQ\n");
 418                         priv->can.can_stats.error_warning++;
 419
 420                         cf->can_id |= CAN_ERR_CRTL;
 421                         cf->data[1] = (bec.txerr > bec.rxerr) ?
 422                                 CAN_ERR_CRTL_TX_WARNING :
 423                                 CAN_ERR_CRTL_RX_WARNING;
 424                 }
 425         case CAN_STATE_ERROR_WARNING:   /* fallthrough */
 426                 /*
 427                  * from: ERROR_ACTIVE, ERROR_WARNING
 428                  * to  : ERROR_PASSIVE, BUS_OFF
 429                  * =>  : error passive int
 430                  */
 431                 if (new_state >= CAN_STATE_ERROR_PASSIVE &&
 432                     new_state <= CAN_STATE_BUS_OFF) {
 433                         dev_dbg(dev->dev.parent, "Error Passive IRQ\n");
 434                         priv->can.can_stats.error_passive++;
 435
 436                         cf->can_id |= CAN_ERR_CRTL;
 437                         cf->data[1] = (bec.txerr > bec.rxerr) ?
 438                                 CAN_ERR_CRTL_TX_PASSIVE :
 439                                 CAN_ERR_CRTL_RX_PASSIVE;
 440                 }
 441                 break;
 442         case CAN_STATE_BUS_OFF:
 443                 dev_err(dev->dev.parent,
 444                         "BUG! hardware recovered automatically from BUS_OFF\n");
 445                 break;
 446         default:
 447                 break;
 448         }
 449
 450         /* process state changes depending on the new state */
 451         switch (new_state) {
 452         case CAN_STATE_ERROR_ACTIVE:
 453                 dev_dbg(dev->dev.parent, "Error Active\n");
 454                 cf->can_id |= CAN_ERR_PROT;
 455                 cf->data[2] = CAN_ERR_PROT_ACTIVE;
 456                 break;
 457         case CAN_STATE_BUS_OFF:
 458                 cf->can_id |= CAN_ERR_BUSOFF;
 459                 can_bus_off(dev);
 460                 break;
 461         default:
 462                 break;
 463         }
 464 }
 465
 466 static int flexcan_poll_state(struct net_device *dev, u32 reg_esr)
 467 {
 468         struct flexcan_priv *priv = netdev_priv(dev);
 469         struct sk_buff *skb;
 470         struct can_frame *cf;
 471         enum can_state new_state;
 472         int flt;
 473
 474         flt = reg_esr & FLEXCAN_ESR_FLT_CONF_MASK;
 475         if (likely(flt == FLEXCAN_ESR_FLT_CONF_ACTIVE)) {
 476                 if (likely(!(reg_esr & (FLEXCAN_ESR_TX_WRN |
 477                                         FLEXCAN_ESR_RX_WRN))))
 478                         new_state = CAN_STATE_ERROR_ACTIVE;
 479                 else
 480                         new_state = CAN_STATE_ERROR_WARNING;
 481         } else if (unlikely(flt == FLEXCAN_ESR_FLT_CONF_PASSIVE))
 482                 new_state = CAN_STATE_ERROR_PASSIVE;
 483         else
 484                 new_state = CAN_STATE_BUS_OFF;
 485
 486         /* state hasn't changed */
 487         if (likely(new_state == priv->can.state))
 488                 return 0;
 489
 490         skb = alloc_can_err_skb(dev, &cf);
 491         if (unlikely(!skb))
 492                 return 0;
 493
 494         do_state(dev, cf, new_state);
 495         priv->can.state = new_state;
 496         netif_receive_skb(skb);
 497
 498         dev->stats.rx_packets++;
 499         dev->stats.rx_bytes += cf->can_dlc;
 500
 501         return 1;
 502 }
 503
 504 static void flexcan_read_fifo(const struct net_device *dev,
 505                               struct can_frame *cf)
 506 {
 507         const struct flexcan_priv *priv = netdev_priv(dev);
 508         struct flexcan_regs __iomem *regs = priv->base;
 509         struct flexcan_mb __iomem *mb = &regs->cantxfg[0];
 510         u32 reg_ctrl, reg_id;
 511
 512         reg_ctrl = flexcan_read(&mb->can_ctrl);
 513         reg_id = flexcan_read(&mb->can_id);
 514         if (reg_ctrl & FLEXCAN_MB_CNT_IDE)
 515                 cf->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG;
 516         else
 517                 cf->can_id = (reg_id >> 18) & CAN_SFF_MASK;
 518
 519         if (reg_ctrl & FLEXCAN_MB_CNT_RTR)
 520                 cf->can_id |= CAN_RTR_FLAG;
 521         cf->can_dlc = get_can_dlc((reg_ctrl >> 16) & 0xf);
 522
 523         *(__be32 *)(cf->data + 0) = cpu_to_be32(flexcan_read(&mb->data[0]));
 524         *(__be32 *)(cf->data + 4) = cpu_to_be32(flexcan_read(&mb->data[1]));
 525
 526         /* mark as read */
 527         flexcan_write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, &regs->iflag1);
 528         flexcan_read(&regs->timer);
 529 }
 530
 531 static int flexcan_read_frame(struct net_device *dev)
 532 {
 533         struct net_device_stats *stats = &dev->stats;
 534         struct can_frame *cf;
 535         struct sk_buff *skb;
 536
 537         skb = alloc_can_skb(dev, &cf);
 538         if (unlikely(!skb)) {
 539                 stats->rx_dropped++;
 540                 return 0;
 541         }
 542
 543         flexcan_read_fifo(dev, cf);
 544         netif_receive_skb(skb);
 545
 546         stats->rx_packets++;
 547         stats->rx_bytes += cf->can_dlc;
 548
 549         return 1;
 550 }
 551
 552 static int flexcan_poll(struct napi_struct *napi, int quota)
 553 {
 554         struct net_device *dev = napi->dev;
 555         const struct flexcan_priv *priv = netdev_priv(dev);
 556         struct flexcan_regs __iomem *regs = priv->base;
 557         u32 reg_iflag1, reg_esr;
 558         int work_done = 0;
 559
 560         /*
 561          * The error bits are cleared on read,
 562          * use saved value from irq handler.
 563          */
 564         reg_esr = flexcan_read(&regs->esr) | priv->reg_esr;
 565
 566         /* handle state changes */
 567         work_done += flexcan_poll_state(dev, reg_esr);
 568
 569         /* handle RX-FIFO */
 570         reg_iflag1 = flexcan_read(&regs->iflag1);
 571         while (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE &&
 572                work_done < quota) {
 573                 work_done += flexcan_read_frame(dev);
 574                 reg_iflag1 = flexcan_read(&regs->iflag1);
 575         }
 576
 577         /* report bus errors */
 578         if (flexcan_has_and_handle_berr(priv, reg_esr) && work_done < quota)
 579                 work_done += flexcan_poll_bus_err(dev, reg_esr);
 580
 581         if (work_done < quota) {
 582                 napi_complete(napi);
 583                 /* enable IRQs */
 584                 flexcan_write(FLEXCAN_IFLAG_DEFAULT, &regs->imask1);
 585                 flexcan_write(priv->reg_ctrl_default, &regs->ctrl);
 586         }
 587
 588         return work_done;
 589 }
 590
 591 static irqreturn_t flexcan_irq(int irq, void *dev_id)
 592 {
 593         struct net_device *dev = dev_id;
 594         struct net_device_stats *stats = &dev->stats;
 595         struct flexcan_priv *priv = netdev_priv(dev);
 596         struct flexcan_regs __iomem *regs = priv->base;
 597         u32 reg_iflag1, reg_esr;
 598
 599         reg_iflag1 = flexcan_read(&regs->iflag1);
 600         reg_esr = flexcan_read(&regs->esr);
 601         flexcan_write(FLEXCAN_ESR_ERR_INT, &regs->esr); /* ACK err IRQ */
 602
 603         /*
 604          * schedule NAPI in case of:
 605          * - rx IRQ
 606          * - state change IRQ
 607          * - bus error IRQ and bus error reporting is activated
 608          */
 609         if ((reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE) ||
 610             (reg_esr & FLEXCAN_ESR_ERR_STATE) ||
 611             flexcan_has_and_handle_berr(priv, reg_esr)) {
 612                 /*
 613                  * The error bits are cleared on read,
 614                  * save them for later use.
 615                  */
 616                 priv->reg_esr = reg_esr & FLEXCAN_ESR_ERR_BUS;
 617                 flexcan_write(FLEXCAN_IFLAG_DEFAULT &
 618                         ~FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, &regs->imask1);
 619                 flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL,
 620                        &regs->ctrl);
 621                 napi_schedule(&priv->napi);
 622         }
 623
 624         /* FIFO overflow */
 625         if (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_OVERFLOW) {
 626                 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW, &regs->iflag1);
 627                 dev->stats.rx_over_errors++;
 628                 dev->stats.rx_errors++;
 629         }
 630
 631         /* transmission complete interrupt */
 632         if (reg_iflag1 & (1 << FLEXCAN_TX_BUF_ID)) {
 633                 /* tx_bytes is incremented in flexcan_start_xmit */
 634                 stats->tx_packets++;
 635                 /* after sending a RTR frame mailbox is in RX mode */
 636                 flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
 637                               &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl);
 638                 flexcan_write((1 << FLEXCAN_TX_BUF_ID), &regs->iflag1);
 639                 netif_wake_queue(dev);
 640         }
 641
 642         return IRQ_HANDLED;
 643 }
 644
 645 static void flexcan_set_bittiming(struct net_device *dev)
 646 {
 647         const struct flexcan_priv *priv = netdev_priv(dev);
 648         const struct can_bittiming *bt = &priv->can.bittiming;
 649         struct flexcan_regs __iomem *regs = priv->base;
 650         u32 reg;
 651
 652         reg = flexcan_read(&regs->ctrl);
 653         reg &= ~(FLEXCAN_CTRL_PRESDIV(0xff) |
 654                  FLEXCAN_CTRL_RJW(0x3) |
 655                  FLEXCAN_CTRL_PSEG1(0x7) |
 656                  FLEXCAN_CTRL_PSEG2(0x7) |
 657                  FLEXCAN_CTRL_PROPSEG(0x7) |
 658                  FLEXCAN_CTRL_LPB |
 659                  FLEXCAN_CTRL_SMP |
 660                  FLEXCAN_CTRL_LOM);
 661
 662         reg |= FLEXCAN_CTRL_PRESDIV(bt->brp - 1) |
 663                 FLEXCAN_CTRL_PSEG1(bt->phase_seg1 - 1) |
 664                 FLEXCAN_CTRL_PSEG2(bt->phase_seg2 - 1) |
 665                 FLEXCAN_CTRL_RJW(bt->sjw - 1) |
 666                 FLEXCAN_CTRL_PROPSEG(bt->prop_seg - 1);
 667
 668         if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
 669                 reg |= FLEXCAN_CTRL_LPB;
 670         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 671                 reg |= FLEXCAN_CTRL_LOM;
 672         if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 673                 reg |= FLEXCAN_CTRL_SMP;
 674
 675         dev_info(dev->dev.parent, "writing ctrl=0x%08x\n", reg);
 676         flexcan_write(reg, &regs->ctrl);
 677
 678         /* print chip status */
 679         dev_dbg(dev->dev.parent, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__,
 680                 flexcan_read(&regs->mcr), flexcan_read(&regs->ctrl));
 681 }
 682
 683 /*
 684  * flexcan_chip_start
 685  *
 686  * this functions is entered with clocks enabled
 687  *
 688  */
 689 static int flexcan_chip_start(struct net_device *dev)
 690 {
 691         struct flexcan_priv *priv = netdev_priv(dev);
 692         struct flexcan_regs __iomem *regs = priv->base;
 693         int err;
 694         u32 reg_mcr, reg_ctrl;
 695         int i;
 696
 697         /* enable module */
 698         flexcan_chip_enable(priv);
 699
 700         /* soft reset */
 701         flexcan_write(FLEXCAN_MCR_SOFTRST, &regs->mcr);
 702         udelay(10);
 703
 704         reg_mcr = flexcan_read(&regs->mcr);
 705         if (reg_mcr & FLEXCAN_MCR_SOFTRST) {
 706                 dev_err(dev->dev.parent,
 707                         "Failed to softreset can module (mcr=0x%08x)\n",
 708                         reg_mcr);
 709                 err = -ENODEV;
 710                 goto out;
 711         }
 712
 713         flexcan_set_bittiming(dev);
 714
 715         /*
 716          * MCR
 717          *
 718          * enable freeze
 719          * enable fifo
 720          * halt now
 721          * only supervisor access
 722          * enable warning int
 723          * choose format C
 724          *
 725          */
 726         reg_mcr = flexcan_read(&regs->mcr);
 727         reg_mcr &= ~FLEXCAN_MCR_MAXMB(0xff);
 728         reg_mcr |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_FEN | FLEXCAN_MCR_HALT |
 729                 FLEXCAN_MCR_SUPV | FLEXCAN_MCR_WRN_EN |
 730                 FLEXCAN_MCR_IDAM_C |
 731                 FLEXCAN_MCR_MAXMB(FLEXCAN_TX_BUF_ID);
 732         dev_dbg(dev->dev.parent, "%s: writing mcr=0x%08x", __func__, reg_mcr);
 733         flexcan_write(reg_mcr, &regs->mcr);
 734
 735         /*
 736          * CTRL
 737          *
 738          * disable timer sync feature
 739          *
 740          * disable auto busoff recovery
 741          * transmit lowest buffer first
 742          *
 743          * enable tx and rx warning interrupt
 744          * enable bus off interrupt
 745          * (== FLEXCAN_CTRL_ERR_STATE)
 746          *
 747          * _note_: we enable the "error interrupt"
 748          * (FLEXCAN_CTRL_ERR_MSK), too. Otherwise we don't get any
 749          * warning or bus passive interrupts.
 750          */
 751         reg_ctrl = flexcan_read(&regs->ctrl);
 752         reg_ctrl &= ~FLEXCAN_CTRL_TSYN;
 753         reg_ctrl |= FLEXCAN_CTRL_BOFF_REC | FLEXCAN_CTRL_LBUF |
 754                 FLEXCAN_CTRL_ERR_STATE | FLEXCAN_CTRL_ERR_MSK;
 755
 756         /* save for later use */
 757         priv->reg_ctrl_default = reg_ctrl;
 758         dev_dbg(dev->dev.parent, "%s: writing ctrl=0x%08x", __func__, reg_ctrl);
 759         flexcan_write(reg_ctrl, &regs->ctrl);
 760
 761         /* clear and invalidate all mailboxes first */
 762         for (i = FLEXCAN_TX_BUF_ID; i < ARRAY_SIZE(regs->cantxfg); i++) {
 763                 flexcan_write(FLEXCAN_MB_CODE_RX_INACTIVE,
 764                               &regs->cantxfg[i].can_ctrl);
 765         }
 766
 767         /* Errata ERR005829: mark first TX mailbox as INACTIVE */
 768         flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
 769                       &regs->cantxfg[FLEXCAN_TX_BUF_RESERVED].can_ctrl);
 770
 771         /* mark TX mailbox as INACTIVE */
 772         flexcan_write(FLEXCAN_MB_CODE_TX_INACTIVE,
 773                       &regs->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl);
 774
 775         /* acceptance mask/acceptance code (accept everything) */
 776         flexcan_write(0x0, &regs->rxgmask);
 777         flexcan_write(0x0, &regs->rx14mask);
 778         flexcan_write(0x0, &regs->rx15mask);
 779
 780         flexcan_transceiver_switch(priv, 1);
 781
 782         /* synchronize with the can bus */
 783         reg_mcr = flexcan_read(&regs->mcr);
 784         reg_mcr &= ~FLEXCAN_MCR_HALT;
 785         flexcan_write(reg_mcr, &regs->mcr);
 786
 787         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 788
 789         /* enable FIFO interrupts */
 790         flexcan_write(FLEXCAN_IFLAG_DEFAULT, &regs->imask1);
 791
 792         /* print chip status */
 793         dev_dbg(dev->dev.parent, "%s: reading mcr=0x%08x ctrl=0x%08x\n",
 794                 __func__, flexcan_read(&regs->mcr), flexcan_read(&regs->ctrl));
 795
 796         return 0;
 797
 798  out:
 799         flexcan_chip_disable(priv);
 800         return err;
 801 }
 802
 803 /*
 804  * flexcan_chip_stop
 805  *
 806  * this functions is entered with clocks enabled
 807  *
 808  */
 809 static void flexcan_chip_stop(struct net_device *dev)
 810 {
 811         struct flexcan_priv *priv = netdev_priv(dev);
 812         struct flexcan_regs __iomem *regs = priv->base;
 813         u32 reg;
 814
 815         /* Disable + halt module */
 816         reg = flexcan_read(&regs->mcr);
 817         reg |= FLEXCAN_MCR_MDIS | FLEXCAN_MCR_HALT;
 818         flexcan_write(reg, &regs->mcr);
 819
 820         /* Disable all interrupts */
 821         flexcan_write(0, &regs->imask1);
 822         flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL,
 823                       &regs->ctrl);
 824
 825         flexcan_transceiver_switch(priv, 0);
 826         priv->can.state = CAN_STATE_STOPPED;
 827
 828         return;
 829 }
 830
 831 static int flexcan_open(struct net_device *dev)
 832 {
 833         struct flexcan_priv *priv = netdev_priv(dev);
 834         int err;
 835
 836         clk_enable(priv->clk);
 837
 838         err = open_candev(dev);
 839         if (err)
 840                 goto out;
 841
 842         err = request_irq(dev->irq, flexcan_irq, IRQF_SHARED, dev->name, dev);
 843         if (err)
 844                 goto out_close;
 845
 846         /* start chip and queuing */
 847         err = flexcan_chip_start(dev);
 848         if (err)
 849                 goto out_free_irq;
 850         napi_enable(&priv->napi);
 851         netif_start_queue(dev);
 852
 853         return 0;
 854
 855  out_free_irq:
 856         free_irq(dev->irq, dev);
 857  out_close:
 858         close_candev(dev);
 859  out:
 860         clk_disable(priv->clk);
 861
 862         return err;
 863 }
 864
 865 static int flexcan_close(struct net_device *dev)
 866 {
 867         struct flexcan_priv *priv = netdev_priv(dev);
 868
 869         netif_stop_queue(dev);
 870         napi_disable(&priv->napi);
 871         flexcan_chip_stop(dev);
 872
 873         free_irq(dev->irq, dev);
 874         clk_disable(priv->clk);
 875
 876         close_candev(dev);
 877
 878         return 0;
 879 }
 880
 881 static int flexcan_set_mode(struct net_device *dev, enum can_mode mode)
 882 {
 883         int err;
 884
 885         switch (mode) {
 886         case CAN_MODE_START:
 887                 err = flexcan_chip_start(dev);
 888                 if (err)
 889                         return err;
 890
 891                 netif_wake_queue(dev);
 892                 break;
 893
 894         default:
 895                 return -EOPNOTSUPP;
 896         }
 897
 898         return 0;
 899 }
 900
 901 static const struct net_device_ops flexcan_netdev_ops = {
 902         .ndo_open       = flexcan_open,
 903         .ndo_stop       = flexcan_close,
 904         .ndo_start_xmit = flexcan_start_xmit,
 905 };
 906
 907 static int __devinit register_flexcandev(struct net_device *dev)
 908 {
 909         struct flexcan_priv *priv = netdev_priv(dev);
 910         struct flexcan_regs __iomem *regs = priv->base;
 911         u32 reg, err;
 912
 913         clk_enable(priv->clk);
 914
 915         /* select "bus clock", chip must be disabled */
 916         flexcan_chip_disable(priv);
 917         reg = flexcan_read(&regs->ctrl);
 918         reg |= FLEXCAN_CTRL_CLK_SRC;
 919         flexcan_write(reg, &regs->ctrl);
 920
 921         flexcan_chip_enable(priv);
 922
 923         /* set freeze, halt and activate FIFO, restrict register access */
 924         reg = flexcan_read(&regs->mcr);
 925         reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT |
 926                 FLEXCAN_MCR_FEN | FLEXCAN_MCR_SUPV;
 927         flexcan_write(reg, &regs->mcr);
 928
 929         /*
 930          * Currently we only support newer versions of this core
 931          * featuring a RX FIFO. Older cores found on some Coldfire
 932          * derivates are not yet supported.
 933          */
 934         reg = flexcan_read(&regs->mcr);
 935         if (!(reg & FLEXCAN_MCR_FEN)) {
 936                 dev_err(dev->dev.parent,
 937                         "Could not enable RX FIFO, unsupported core\n");
 938                 err = -ENODEV;
 939                 goto out;
 940         }
 941
 942         err = register_candev(dev);
 943
 944  out:
 945         /* disable core and turn off clocks */
 946         flexcan_chip_disable(priv);
 947         clk_disable(priv->clk);
 948
 949         return err;
 950 }
 951
 952 static void __devexit unregister_flexcandev(struct net_device *dev)
 953 {
 954         unregister_candev(dev);
 955 }
 956
 957 static int __devinit flexcan_probe(struct platform_device *pdev)
 958 {
 959         struct net_device *dev;
 960         struct flexcan_priv *priv;
 961         struct resource *mem;
 962         struct clk *clk = NULL;
 963         void __iomem *base;
 964         resource_size_t mem_size;
 965         int err, irq;
 966         u32 clock_freq = 0;
 967
 968         if (pdev->dev.of_node) {
 969                 const __be32 *clock_freq_p;
 970
 971                 clock_freq_p = of_get_property(pdev->dev.of_node,
 972                                                 "clock-frequency", NULL);
 973                 if (clock_freq_p)
 974                         clock_freq = be32_to_cpup(clock_freq_p);
 975         }
 976
 977         if (!clock_freq) {
 978                 clk = clk_get(&pdev->dev, NULL);
 979                 if (IS_ERR(clk)) {
 980                         dev_err(&pdev->dev, "no clock defined\n");
 981                         err = PTR_ERR(clk);
 982                         goto failed_clock;
 983                 }
 984                 clock_freq = clk_get_rate(clk);
 985         }
 986
 987         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 988         irq = platform_get_irq(pdev, 0);
 989         if (!mem || irq <= 0) {
 990                 err = -ENODEV;
 991                 goto failed_get;
 992         }
 993
 994         mem_size = resource_size(mem);
 995         if (!request_mem_region(mem->start, mem_size, pdev->name)) {
 996                 err = -EBUSY;
 997                 goto failed_get;
 998         }
 999
1000         base = ioremap(mem->start, mem_size);
1001         if (!base) {
1002                 err = -ENOMEM;
1003                 goto failed_map;
1004         }
1005
1006         dev = alloc_candev(sizeof(struct flexcan_priv), 0);
1007         if (!dev) {
1008                 err = -ENOMEM;
1009                 goto failed_alloc;
1010         }
1011
1012         dev->netdev_ops = &flexcan_netdev_ops;
1013         dev->irq = irq;
1014         dev->flags |= IFF_ECHO; /* we support local echo in hardware */
1015
1016         priv = netdev_priv(dev);
1017         priv->can.clock.freq = clock_freq;
1018         priv->can.bittiming_const = &flexcan_bittiming_const;
1019         priv->can.do_set_mode = flexcan_set_mode;
1020         priv->can.do_get_berr_counter = flexcan_get_berr_counter;
1021         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
1022                 CAN_CTRLMODE_LISTENONLY | CAN_CTRLMODE_3_SAMPLES |
1023                 CAN_CTRLMODE_BERR_REPORTING;
1024         priv->base = base;
1025         priv->dev = dev;
1026         priv->clk = clk;
1027         priv->pdata = pdev->dev.platform_data;
1028
1029         netif_napi_add(dev, &priv->napi, flexcan_poll, FLEXCAN_NAPI_WEIGHT);
1030
1031         dev_set_drvdata(&pdev->dev, dev);
1032         SET_NETDEV_DEV(dev, &pdev->dev);
1033
1034         err = register_flexcandev(dev);
1035         if (err) {
1036                 dev_err(&pdev->dev, "registering netdev failed\n");
1037                 goto failed_register;
1038         }
1039
1040         dev_info(&pdev->dev, "device registered (reg_base=%p, irq=%d)\n",
1041                  priv->base, dev->irq);
1042
1043         return 0;
1044
1045  failed_register:
1046         free_candev(dev);
1047  failed_alloc:
1048         iounmap(base);
1049  failed_map:
1050         release_mem_region(mem->start, mem_size);
1051  failed_get:
1052         if (clk)
1053                 clk_put(clk);
1054  failed_clock:
1055         return err;
1056 }
1057
1058 static int __devexit flexcan_remove(struct platform_device *pdev)
1059 {
1060         struct net_device *dev = platform_get_drvdata(pdev);
1061         struct flexcan_priv *priv = netdev_priv(dev);
1062         struct resource *mem;
1063
1064         unregister_flexcandev(dev);
1065         netif_napi_del(&priv->napi);
1066         platform_set_drvdata(pdev, NULL);
1067         iounmap(priv->base);
1068
1069         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1070         release_mem_region(mem->start, resource_size(mem));
1071
1072         if (priv->clk)
1073                 clk_put(priv->clk);
1074
1075         free_candev(dev);
1076
1077         return 0;
1078 }
1079
1080 static struct of_device_id flexcan_of_match[] = {
1081         {
1082                 .compatible = "fsl,p1010-flexcan",
1083         },
1084         {},
1085 };
1086
1087 static struct platform_driver flexcan_driver = {
1088         .driver = {
1089                 .name = DRV_NAME,
1090                 .owner = THIS_MODULE,
1091                 .of_match_table = flexcan_of_match,
1092         },
1093         .probe = flexcan_probe,
1094         .remove = __devexit_p(flexcan_remove),
1095 };
1096
1097 static int __init flexcan_init(void)
1098 {
1099         pr_info("%s netdevice driver\n", DRV_NAME);
1100         return platform_driver_register(&flexcan_driver);
1101 }
1102
1103 static void __exit flexcan_exit(void)
1104 {
1105         platform_driver_unregister(&flexcan_driver);
1106         pr_info("%s: driver removed\n", DRV_NAME);
1107 }
1108
1109 module_init(flexcan_init);
1110 module_exit(flexcan_exit);
1111
1112 MODULE_AUTHOR("Sascha Hauer <kernel@pengutronix.de>, "
1113               "Marc Kleine-Budde <kernel@pengutronix.de>");
1114 MODULE_LICENSE("GPL v2");
1115 MODULE_DESCRIPTION("CAN port driver for flexcan based chip");