drivers/net/can/m_can/m_can.c

   1 /*
   2  * CAN bus driver for Bosch M_CAN controller
   3  *
   4  * Copyright (C) 2014 Freescale Semiconductor, Inc.
   5  *      Dong Aisheng <b29396@freescale.com>
   6  *
   7  * Bosch M_CAN user manual can be obtained from:
   8  * http://www.bosch-semiconductors.de/media/pdf_1/ipmodules_1/m_can/
   9  * mcan_users_manual_v302.pdf
  10  *
  11  * This file is licensed under the terms of the GNU General Public
  12  * License version 2. This program is licensed "as is" without any
  13  * warranty of any kind, whether express or implied.
  14  */
  15
  16 #include <linux/clk.h>
  17 #include <linux/delay.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/io.h>
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/of.h>
  24 #include <linux/of_device.h>
  25 #include <linux/platform_device.h>
  26
  27 #include <linux/can/dev.h>
  28
  29 /* napi related */
  30 #define M_CAN_NAPI_WEIGHT       64
  31
  32 /* message ram configuration data length */
  33 #define MRAM_CFG_LEN    8
  34
  35 /* registers definition */
  36 enum m_can_reg {
  37         M_CAN_CREL      = 0x0,
  38         M_CAN_ENDN      = 0x4,
  39         M_CAN_CUST      = 0x8,
  40         M_CAN_FBTP      = 0xc,
  41         M_CAN_TEST      = 0x10,
  42         M_CAN_RWD       = 0x14,
  43         M_CAN_CCCR      = 0x18,
  44         M_CAN_BTP       = 0x1c,
  45         M_CAN_TSCC      = 0x20,
  46         M_CAN_TSCV      = 0x24,
  47         M_CAN_TOCC      = 0x28,
  48         M_CAN_TOCV      = 0x2c,
  49         M_CAN_ECR       = 0x40,
  50         M_CAN_PSR       = 0x44,
  51         M_CAN_IR        = 0x50,
  52         M_CAN_IE        = 0x54,
  53         M_CAN_ILS       = 0x58,
  54         M_CAN_ILE       = 0x5c,
  55         M_CAN_GFC       = 0x80,
  56         M_CAN_SIDFC     = 0x84,
  57         M_CAN_XIDFC     = 0x88,
  58         M_CAN_XIDAM     = 0x90,
  59         M_CAN_HPMS      = 0x94,
  60         M_CAN_NDAT1     = 0x98,
  61         M_CAN_NDAT2     = 0x9c,
  62         M_CAN_RXF0C     = 0xa0,
  63         M_CAN_RXF0S     = 0xa4,
  64         M_CAN_RXF0A     = 0xa8,
  65         M_CAN_RXBC      = 0xac,
  66         M_CAN_RXF1C     = 0xb0,
  67         M_CAN_RXF1S     = 0xb4,
  68         M_CAN_RXF1A     = 0xb8,
  69         M_CAN_RXESC     = 0xbc,
  70         M_CAN_TXBC      = 0xc0,
  71         M_CAN_TXFQS     = 0xc4,
  72         M_CAN_TXESC     = 0xc8,
  73         M_CAN_TXBRP     = 0xcc,
  74         M_CAN_TXBAR     = 0xd0,
  75         M_CAN_TXBCR     = 0xd4,
  76         M_CAN_TXBTO     = 0xd8,
  77         M_CAN_TXBCF     = 0xdc,
  78         M_CAN_TXBTIE    = 0xe0,
  79         M_CAN_TXBCIE    = 0xe4,
  80         M_CAN_TXEFC     = 0xf0,
  81         M_CAN_TXEFS     = 0xf4,
  82         M_CAN_TXEFA     = 0xf8,
  83 };
  84
  85 /* m_can lec values */
  86 enum m_can_lec_type {
  87         LEC_NO_ERROR = 0,
  88         LEC_STUFF_ERROR,
  89         LEC_FORM_ERROR,
  90         LEC_ACK_ERROR,
  91         LEC_BIT1_ERROR,
  92         LEC_BIT0_ERROR,
  93         LEC_CRC_ERROR,
  94         LEC_UNUSED,
  95 };
  96
  97 enum m_can_mram_cfg {
  98         MRAM_SIDF = 0,
  99         MRAM_XIDF,
 100         MRAM_RXF0,
 101         MRAM_RXF1,
 102         MRAM_RXB,
 103         MRAM_TXE,
 104         MRAM_TXB,
 105         MRAM_CFG_NUM,
 106 };
 107
 108 /* Fast Bit Timing & Prescaler Register (FBTP) */
 109 #define FBTR_FBRP_MASK          0x1f
 110 #define FBTR_FBRP_SHIFT         16
 111 #define FBTR_FTSEG1_SHIFT       8
 112 #define FBTR_FTSEG1_MASK        (0xf << FBTR_FTSEG1_SHIFT)
 113 #define FBTR_FTSEG2_SHIFT       4
 114 #define FBTR_FTSEG2_MASK        (0x7 << FBTR_FTSEG2_SHIFT)
 115 #define FBTR_FSJW_SHIFT         0
 116 #define FBTR_FSJW_MASK          0x3
 117
 118 /* Test Register (TEST) */
 119 #define TEST_LBCK       BIT(4)
 120
 121 /* CC Control Register(CCCR) */
 122 #define CCCR_TEST               BIT(7)
 123 #define CCCR_CMR_MASK           0x3
 124 #define CCCR_CMR_SHIFT          10
 125 #define CCCR_CMR_CANFD          0x1
 126 #define CCCR_CMR_CANFD_BRS      0x2
 127 #define CCCR_CMR_CAN            0x3
 128 #define CCCR_CME_MASK           0x3
 129 #define CCCR_CME_SHIFT          8
 130 #define CCCR_CME_CAN            0
 131 #define CCCR_CME_CANFD          0x1
 132 #define CCCR_CME_CANFD_BRS      0x2
 133 #define CCCR_TEST               BIT(7)
 134 #define CCCR_MON                BIT(5)
 135 #define CCCR_CCE                BIT(1)
 136 #define CCCR_INIT               BIT(0)
 137 #define CCCR_CANFD              0x10
 138
 139 /* Bit Timing & Prescaler Register (BTP) */
 140 #define BTR_BRP_MASK            0x3ff
 141 #define BTR_BRP_SHIFT           16
 142 #define BTR_TSEG1_SHIFT         8
 143 #define BTR_TSEG1_MASK          (0x3f << BTR_TSEG1_SHIFT)
 144 #define BTR_TSEG2_SHIFT         4
 145 #define BTR_TSEG2_MASK          (0xf << BTR_TSEG2_SHIFT)
 146 #define BTR_SJW_SHIFT           0
 147 #define BTR_SJW_MASK            0xf
 148
 149 /* Error Counter Register(ECR) */
 150 #define ECR_RP                  BIT(15)
 151 #define ECR_REC_SHIFT           8
 152 #define ECR_REC_MASK            (0x7f << ECR_REC_SHIFT)
 153 #define ECR_TEC_SHIFT           0
 154 #define ECR_TEC_MASK            0xff
 155
 156 /* Protocol Status Register(PSR) */
 157 #define PSR_BO          BIT(7)
 158 #define PSR_EW          BIT(6)
 159 #define PSR_EP          BIT(5)
 160 #define PSR_LEC_MASK    0x7
 161
 162 /* Interrupt Register(IR) */
 163 #define IR_ALL_INT      0xffffffff
 164 #define IR_STE          BIT(31)
 165 #define IR_FOE          BIT(30)
 166 #define IR_ACKE         BIT(29)
 167 #define IR_BE           BIT(28)
 168 #define IR_CRCE         BIT(27)
 169 #define IR_WDI          BIT(26)
 170 #define IR_BO           BIT(25)
 171 #define IR_EW           BIT(24)
 172 #define IR_EP           BIT(23)
 173 #define IR_ELO          BIT(22)
 174 #define IR_BEU          BIT(21)
 175 #define IR_BEC          BIT(20)
 176 #define IR_DRX          BIT(19)
 177 #define IR_TOO          BIT(18)
 178 #define IR_MRAF         BIT(17)
 179 #define IR_TSW          BIT(16)
 180 #define IR_TEFL         BIT(15)
 181 #define IR_TEFF         BIT(14)
 182 #define IR_TEFW         BIT(13)
 183 #define IR_TEFN         BIT(12)
 184 #define IR_TFE          BIT(11)
 185 #define IR_TCF          BIT(10)
 186 #define IR_TC           BIT(9)
 187 #define IR_HPM          BIT(8)
 188 #define IR_RF1L         BIT(7)
 189 #define IR_RF1F         BIT(6)
 190 #define IR_RF1W         BIT(5)
 191 #define IR_RF1N         BIT(4)
 192 #define IR_RF0L         BIT(3)
 193 #define IR_RF0F         BIT(2)
 194 #define IR_RF0W         BIT(1)
 195 #define IR_RF0N         BIT(0)
 196 #define IR_ERR_STATE    (IR_BO | IR_EW | IR_EP)
 197 #define IR_ERR_LEC      (IR_STE | IR_FOE | IR_ACKE | IR_BE | IR_CRCE)
 198 #define IR_ERR_BUS      (IR_ERR_LEC | IR_WDI | IR_ELO | IR_BEU | \
 199                          IR_BEC | IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | \
 200                          IR_RF1L | IR_RF0L)
 201 #define IR_ERR_ALL      (IR_ERR_STATE | IR_ERR_BUS)
 202
 203 /* Interrupt Line Select (ILS) */
 204 #define ILS_ALL_INT0    0x0
 205 #define ILS_ALL_INT1    0xFFFFFFFF
 206
 207 /* Interrupt Line Enable (ILE) */
 208 #define ILE_EINT0       BIT(0)
 209 #define ILE_EINT1       BIT(1)
 210
 211 /* Rx FIFO 0/1 Configuration (RXF0C/RXF1C) */
 212 #define RXFC_FWM_OFF    24
 213 #define RXFC_FWM_MASK   0x7f
 214 #define RXFC_FWM_1      (1 << RXFC_FWM_OFF)
 215 #define RXFC_FS_OFF     16
 216 #define RXFC_FS_MASK    0x7f
 217
 218 /* Rx FIFO 0/1 Status (RXF0S/RXF1S) */
 219 #define RXFS_RFL        BIT(25)
 220 #define RXFS_FF         BIT(24)
 221 #define RXFS_FPI_OFF    16
 222 #define RXFS_FPI_MASK   0x3f0000
 223 #define RXFS_FGI_OFF    8
 224 #define RXFS_FGI_MASK   0x3f00
 225 #define RXFS_FFL_MASK   0x7f
 226
 227 /* Rx Buffer / FIFO Element Size Configuration (RXESC) */
 228 #define M_CAN_RXESC_8BYTES      0x0
 229 #define M_CAN_RXESC_64BYTES     0x777
 230
 231 /* Tx Buffer Configuration(TXBC) */
 232 #define TXBC_NDTB_OFF           16
 233 #define TXBC_NDTB_MASK          0x3f
 234
 235 /* Tx Buffer Element Size Configuration(TXESC) */
 236 #define TXESC_TBDS_8BYTES       0x0
 237 #define TXESC_TBDS_64BYTES      0x7
 238
 239 /* Tx Event FIFO Con.guration (TXEFC) */
 240 #define TXEFC_EFS_OFF           16
 241 #define TXEFC_EFS_MASK          0x3f
 242
 243 /* Message RAM Configuration (in bytes) */
 244 #define SIDF_ELEMENT_SIZE       4
 245 #define XIDF_ELEMENT_SIZE       8
 246 #define RXF0_ELEMENT_SIZE       72
 247 #define RXF1_ELEMENT_SIZE       72
 248 #define RXB_ELEMENT_SIZE        16
 249 #define TXE_ELEMENT_SIZE        8
 250 #define TXB_ELEMENT_SIZE        72
 251
 252 /* Message RAM Elements */
 253 #define M_CAN_FIFO_ID           0x0
 254 #define M_CAN_FIFO_DLC          0x4
 255 #define M_CAN_FIFO_DATA(n)      (0x8 + ((n) << 2))
 256
 257 /* Rx Buffer Element */
 258 /* R0 */
 259 #define RX_BUF_ESI              BIT(31)
 260 #define RX_BUF_XTD              BIT(30)
 261 #define RX_BUF_RTR              BIT(29)
 262 /* R1 */
 263 #define RX_BUF_ANMF             BIT(31)
 264 #define RX_BUF_EDL              BIT(21)
 265 #define RX_BUF_BRS              BIT(20)
 266
 267 /* Tx Buffer Element */
 268 /* R0 */
 269 #define TX_BUF_XTD              BIT(30)
 270 #define TX_BUF_RTR              BIT(29)
 271
 272 /* address offset and element number for each FIFO/Buffer in the Message RAM */
 273 struct mram_cfg {
 274         u16 off;
 275         u8  num;
 276 };
 277
 278 /* m_can private data structure */
 279 struct m_can_priv {
 280         struct can_priv can;    /* must be the first member */
 281         struct napi_struct napi;
 282         struct net_device *dev;
 283         struct device *device;
 284         struct clk *hclk;
 285         struct clk *cclk;
 286         void __iomem *base;
 287         u32 irqstatus;
 288
 289         /* message ram configuration */
 290         void __iomem *mram_base;
 291         struct mram_cfg mcfg[MRAM_CFG_NUM];
 292 };
 293
 294 static inline u32 m_can_read(const struct m_can_priv *priv, enum m_can_reg reg)
 295 {
 296         return readl(priv->base + reg);
 297 }
 298
 299 static inline void m_can_write(const struct m_can_priv *priv,
 300                                enum m_can_reg reg, u32 val)
 301 {
 302         writel(val, priv->base + reg);
 303 }
 304
 305 static inline u32 m_can_fifo_read(const struct m_can_priv *priv,
 306                                   u32 fgi, unsigned int offset)
 307 {
 308         return readl(priv->mram_base + priv->mcfg[MRAM_RXF0].off +
 309                      fgi * RXF0_ELEMENT_SIZE + offset);
 310 }
 311
 312 static inline void m_can_fifo_write(const struct m_can_priv *priv,
 313                                     u32 fpi, unsigned int offset, u32 val)
 314 {
 315         writel(val, priv->mram_base + priv->mcfg[MRAM_TXB].off +
 316                fpi * TXB_ELEMENT_SIZE + offset);
 317 }
 318
 319 static inline void m_can_config_endisable(const struct m_can_priv *priv,
 320                                           bool enable)
 321 {
 322         u32 cccr = m_can_read(priv, M_CAN_CCCR);
 323         u32 timeout = 10;
 324         u32 val = 0;
 325
 326         if (enable) {
 327                 /* enable m_can configuration */
 328                 m_can_write(priv, M_CAN_CCCR, cccr | CCCR_INIT);
 329                 udelay(5);
 330                 /* CCCR.CCE can only be set/reset while CCCR.INIT = '1' */
 331                 m_can_write(priv, M_CAN_CCCR, cccr | CCCR_INIT | CCCR_CCE);
 332         } else {
 333                 m_can_write(priv, M_CAN_CCCR, cccr & ~(CCCR_INIT | CCCR_CCE));
 334         }
 335
 336         /* there's a delay for module initialization */
 337         if (enable)
 338                 val = CCCR_INIT | CCCR_CCE;
 339
 340         while ((m_can_read(priv, M_CAN_CCCR) & (CCCR_INIT | CCCR_CCE)) != val) {
 341                 if (timeout == 0) {
 342                         netdev_warn(priv->dev, "Failed to init module\n");
 343                         return;
 344                 }
 345                 timeout--;
 346                 udelay(1);
 347         }
 348 }
 349
 350 static inline void m_can_enable_all_interrupts(const struct m_can_priv *priv)
 351 {
 352         m_can_write(priv, M_CAN_ILE, ILE_EINT0 | ILE_EINT1);
 353 }
 354
 355 static inline void m_can_disable_all_interrupts(const struct m_can_priv *priv)
 356 {
 357         m_can_write(priv, M_CAN_ILE, 0x0);
 358 }
 359
 360 static void m_can_read_fifo(struct net_device *dev, u32 rxfs)
 361 {
 362         struct net_device_stats *stats = &dev->stats;
 363         struct m_can_priv *priv = netdev_priv(dev);
 364         struct canfd_frame *cf;
 365         struct sk_buff *skb;
 366         u32 id, fgi, dlc;
 367         int i;
 368
 369         /* calculate the fifo get index for where to read data */
 370         fgi = (rxfs & RXFS_FGI_MASK) >> RXFS_FGI_OFF;
 371         dlc = m_can_fifo_read(priv, fgi, M_CAN_FIFO_DLC);
 372         if (dlc & RX_BUF_EDL)
 373                 skb = alloc_canfd_skb(dev, &cf);
 374         else
 375                 skb = alloc_can_skb(dev, (struct can_frame **)&cf);
 376         if (!skb) {
 377                 stats->rx_dropped++;
 378                 return;
 379         }
 380
 381         if (dlc & RX_BUF_EDL)
 382                 cf->len = can_dlc2len((dlc >> 16) & 0x0F);
 383         else
 384                 cf->len = get_can_dlc((dlc >> 16) & 0x0F);
 385
 386         id = m_can_fifo_read(priv, fgi, M_CAN_FIFO_ID);
 387         if (id & RX_BUF_XTD)
 388                 cf->can_id = (id & CAN_EFF_MASK) | CAN_EFF_FLAG;
 389         else
 390                 cf->can_id = (id >> 18) & CAN_SFF_MASK;
 391
 392         if (id & RX_BUF_ESI) {
 393                 cf->flags |= CANFD_ESI;
 394                 netdev_dbg(dev, "ESI Error\n");
 395         }
 396
 397         if (!(dlc & RX_BUF_EDL) && (id & RX_BUF_RTR)) {
 398                 cf->can_id |= CAN_RTR_FLAG;
 399         } else {
 400                 if (dlc & RX_BUF_BRS)
 401                         cf->flags |= CANFD_BRS;
 402
 403                 for (i = 0; i < cf->len; i += 4)
 404                         *(u32 *)(cf->data + i) =
 405                                 m_can_fifo_read(priv, fgi,
 406                                                 M_CAN_FIFO_DATA(i / 4));
 407         }
 408
 409         /* acknowledge rx fifo 0 */
 410         m_can_write(priv, M_CAN_RXF0A, fgi);
 411
 412         stats->rx_packets++;
 413         stats->rx_bytes += cf->len;
 414
 415         netif_receive_skb(skb);
 416 }
 417
 418 static int m_can_do_rx_poll(struct net_device *dev, int quota)
 419 {
 420         struct m_can_priv *priv = netdev_priv(dev);
 421         u32 pkts = 0;
 422         u32 rxfs;
 423
 424         rxfs = m_can_read(priv, M_CAN_RXF0S);
 425         if (!(rxfs & RXFS_FFL_MASK)) {
 426                 netdev_dbg(dev, "no messages in fifo0\n");
 427                 return 0;
 428         }
 429
 430         while ((rxfs & RXFS_FFL_MASK) && (quota > 0)) {
 431                 m_can_read_fifo(dev, rxfs);
 432
 433                 quota--;
 434                 pkts++;
 435                 rxfs = m_can_read(priv, M_CAN_RXF0S);
 436         }
 437
 438         if (pkts)
 439                 can_led_event(dev, CAN_LED_EVENT_RX);
 440
 441         return pkts;
 442 }
 443
 444 static int m_can_handle_lost_msg(struct net_device *dev)
 445 {
 446         struct net_device_stats *stats = &dev->stats;
 447         struct sk_buff *skb;
 448         struct can_frame *frame;
 449
 450         netdev_err(dev, "msg lost in rxf0\n");
 451
 452         stats->rx_errors++;
 453         stats->rx_over_errors++;
 454
 455         skb = alloc_can_err_skb(dev, &frame);
 456         if (unlikely(!skb))
 457                 return 0;
 458
 459         frame->can_id |= CAN_ERR_CRTL;
 460         frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 461
 462         netif_receive_skb(skb);
 463
 464         return 1;
 465 }
 466
 467 static int m_can_handle_lec_err(struct net_device *dev,
 468                                 enum m_can_lec_type lec_type)
 469 {
 470         struct m_can_priv *priv = netdev_priv(dev);
 471         struct net_device_stats *stats = &dev->stats;
 472         struct can_frame *cf;
 473         struct sk_buff *skb;
 474
 475         priv->can.can_stats.bus_error++;
 476         stats->rx_errors++;
 477
 478         /* propagate the error condition to the CAN stack */
 479         skb = alloc_can_err_skb(dev, &cf);
 480         if (unlikely(!skb))
 481                 return 0;
 482
 483         /* check for 'last error code' which tells us the
 484          * type of the last error to occur on the CAN bus
 485          */
 486         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 487
 488         switch (lec_type) {
 489         case LEC_STUFF_ERROR:
 490                 netdev_dbg(dev, "stuff error\n");
 491                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 492                 break;
 493         case LEC_FORM_ERROR:
 494                 netdev_dbg(dev, "form error\n");
 495                 cf->data[2] |= CAN_ERR_PROT_FORM;
 496                 break;
 497         case LEC_ACK_ERROR:
 498                 netdev_dbg(dev, "ack error\n");
 499                 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
 500                 break;
 501         case LEC_BIT1_ERROR:
 502                 netdev_dbg(dev, "bit1 error\n");
 503                 cf->data[2] |= CAN_ERR_PROT_BIT1;
 504                 break;
 505         case LEC_BIT0_ERROR:
 506                 netdev_dbg(dev, "bit0 error\n");
 507                 cf->data[2] |= CAN_ERR_PROT_BIT0;
 508                 break;
 509         case LEC_CRC_ERROR:
 510                 netdev_dbg(dev, "CRC error\n");
 511                 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
 512                 break;
 513         default:
 514                 break;
 515         }
 516
 517         stats->rx_packets++;
 518         stats->rx_bytes += cf->can_dlc;
 519         netif_receive_skb(skb);
 520
 521         return 1;
 522 }
 523
 524 static int __m_can_get_berr_counter(const struct net_device *dev,
 525                                     struct can_berr_counter *bec)
 526 {
 527         struct m_can_priv *priv = netdev_priv(dev);
 528         unsigned int ecr;
 529
 530         ecr = m_can_read(priv, M_CAN_ECR);
 531         bec->rxerr = (ecr & ECR_REC_MASK) >> ECR_REC_SHIFT;
 532         bec->txerr = ecr & ECR_TEC_MASK;
 533
 534         return 0;
 535 }
 536
 537 static int m_can_get_berr_counter(const struct net_device *dev,
 538                                   struct can_berr_counter *bec)
 539 {
 540         struct m_can_priv *priv = netdev_priv(dev);
 541         int err;
 542
 543         err = clk_prepare_enable(priv->hclk);
 544         if (err)
 545                 return err;
 546
 547         err = clk_prepare_enable(priv->cclk);
 548         if (err) {
 549                 clk_disable_unprepare(priv->hclk);
 550                 return err;
 551         }
 552
 553         __m_can_get_berr_counter(dev, bec);
 554
 555         clk_disable_unprepare(priv->cclk);
 556         clk_disable_unprepare(priv->hclk);
 557
 558         return 0;
 559 }
 560
 561 static int m_can_handle_state_change(struct net_device *dev,
 562                                      enum can_state new_state)
 563 {
 564         struct m_can_priv *priv = netdev_priv(dev);
 565         struct net_device_stats *stats = &dev->stats;
 566         struct can_frame *cf;
 567         struct sk_buff *skb;
 568         struct can_berr_counter bec;
 569         unsigned int ecr;
 570
 571         switch (new_state) {
 572         case CAN_STATE_ERROR_WARNING:
 573                 /* error warning state */
 574                 priv->can.can_stats.error_warning++;
 575                 priv->can.state = CAN_STATE_ERROR_WARNING;
 576                 break;
 577         case CAN_STATE_ERROR_PASSIVE:
 578                 /* error passive state */
 579                 priv->can.can_stats.error_passive++;
 580                 priv->can.state = CAN_STATE_ERROR_PASSIVE;
 581                 break;
 582         case CAN_STATE_BUS_OFF:
 583                 /* bus-off state */
 584                 priv->can.state = CAN_STATE_BUS_OFF;
 585                 m_can_disable_all_interrupts(priv);
 586                 priv->can.can_stats.bus_off++;
 587                 can_bus_off(dev);
 588                 break;
 589         default:
 590                 break;
 591         }
 592
 593         /* propagate the error condition to the CAN stack */
 594         skb = alloc_can_err_skb(dev, &cf);
 595         if (unlikely(!skb))
 596                 return 0;
 597
 598         __m_can_get_berr_counter(dev, &bec);
 599
 600         switch (new_state) {
 601         case CAN_STATE_ERROR_WARNING:
 602                 /* error warning state */
 603                 cf->can_id |= CAN_ERR_CRTL;
 604                 cf->data[1] = (bec.txerr > bec.rxerr) ?
 605                         CAN_ERR_CRTL_TX_WARNING :
 606                         CAN_ERR_CRTL_RX_WARNING;
 607                 cf->data[6] = bec.txerr;
 608                 cf->data[7] = bec.rxerr;
 609                 break;
 610         case CAN_STATE_ERROR_PASSIVE:
 611                 /* error passive state */
 612                 cf->can_id |= CAN_ERR_CRTL;
 613                 ecr = m_can_read(priv, M_CAN_ECR);
 614                 if (ecr & ECR_RP)
 615                         cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
 616                 if (bec.txerr > 127)
 617                         cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
 618                 cf->data[6] = bec.txerr;
 619                 cf->data[7] = bec.rxerr;
 620                 break;
 621         case CAN_STATE_BUS_OFF:
 622                 /* bus-off state */
 623                 cf->can_id |= CAN_ERR_BUSOFF;
 624                 break;
 625         default:
 626                 break;
 627         }
 628
 629         stats->rx_packets++;
 630         stats->rx_bytes += cf->can_dlc;
 631         netif_receive_skb(skb);
 632
 633         return 1;
 634 }
 635
 636 static int m_can_handle_state_errors(struct net_device *dev, u32 psr)
 637 {
 638         struct m_can_priv *priv = netdev_priv(dev);
 639         int work_done = 0;
 640
 641         if ((psr & PSR_EW) &&
 642             (priv->can.state != CAN_STATE_ERROR_WARNING)) {
 643                 netdev_dbg(dev, "entered error warning state\n");
 644                 work_done += m_can_handle_state_change(dev,
 645                                                        CAN_STATE_ERROR_WARNING);
 646         }
 647
 648         if ((psr & PSR_EP) &&
 649             (priv->can.state != CAN_STATE_ERROR_PASSIVE)) {
 650                 netdev_dbg(dev, "entered error passive state\n");
 651                 work_done += m_can_handle_state_change(dev,
 652                                                        CAN_STATE_ERROR_PASSIVE);
 653         }
 654
 655         if ((psr & PSR_BO) &&
 656             (priv->can.state != CAN_STATE_BUS_OFF)) {
 657                 netdev_dbg(dev, "entered error bus off state\n");
 658                 work_done += m_can_handle_state_change(dev,
 659                                                        CAN_STATE_BUS_OFF);
 660         }
 661
 662         return work_done;
 663 }
 664
 665 static void m_can_handle_other_err(struct net_device *dev, u32 irqstatus)
 666 {
 667         if (irqstatus & IR_WDI)
 668                 netdev_err(dev, "Message RAM Watchdog event due to missing READY\n");
 669         if (irqstatus & IR_ELO)
 670                 netdev_err(dev, "Error Logging Overflow\n");
 671         if (irqstatus & IR_BEU)
 672                 netdev_err(dev, "Bit Error Uncorrected\n");
 673         if (irqstatus & IR_BEC)
 674                 netdev_err(dev, "Bit Error Corrected\n");
 675         if (irqstatus & IR_TOO)
 676                 netdev_err(dev, "Timeout reached\n");
 677         if (irqstatus & IR_MRAF)
 678                 netdev_err(dev, "Message RAM access failure occurred\n");
 679 }
 680
 681 static inline bool is_lec_err(u32 psr)
 682 {
 683         psr &= LEC_UNUSED;
 684
 685         return psr && (psr != LEC_UNUSED);
 686 }
 687
 688 static int m_can_handle_bus_errors(struct net_device *dev, u32 irqstatus,
 689                                    u32 psr)
 690 {
 691         struct m_can_priv *priv = netdev_priv(dev);
 692         int work_done = 0;
 693
 694         if (irqstatus & IR_RF0L)
 695                 work_done += m_can_handle_lost_msg(dev);
 696
 697         /* handle lec errors on the bus */
 698         if ((priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) &&
 699             is_lec_err(psr))
 700                 work_done += m_can_handle_lec_err(dev, psr & LEC_UNUSED);
 701
 702         /* other unproccessed error interrupts */
 703         m_can_handle_other_err(dev, irqstatus);
 704
 705         return work_done;
 706 }
 707
 708 static int m_can_poll(struct napi_struct *napi, int quota)
 709 {
 710         struct net_device *dev = napi->dev;
 711         struct m_can_priv *priv = netdev_priv(dev);
 712         int work_done = 0;
 713         u32 irqstatus, psr;
 714
 715         irqstatus = priv->irqstatus | m_can_read(priv, M_CAN_IR);
 716         if (!irqstatus)
 717                 goto end;
 718
 719         psr = m_can_read(priv, M_CAN_PSR);
 720         if (irqstatus & IR_ERR_STATE)
 721                 work_done += m_can_handle_state_errors(dev, psr);
 722
 723         if (irqstatus & IR_ERR_BUS)
 724                 work_done += m_can_handle_bus_errors(dev, irqstatus, psr);
 725
 726         if (irqstatus & IR_RF0N)
 727                 work_done += m_can_do_rx_poll(dev, (quota - work_done));
 728
 729         if (work_done < quota) {
 730                 napi_complete(napi);
 731                 m_can_enable_all_interrupts(priv);
 732         }
 733
 734 end:
 735         return work_done;
 736 }
 737
 738 static irqreturn_t m_can_isr(int irq, void *dev_id)
 739 {
 740         struct net_device *dev = (struct net_device *)dev_id;
 741         struct m_can_priv *priv = netdev_priv(dev);
 742         struct net_device_stats *stats = &dev->stats;
 743         u32 ir;
 744
 745         ir = m_can_read(priv, M_CAN_IR);
 746         if (!ir)
 747                 return IRQ_NONE;
 748
 749         /* ACK all irqs */
 750         if (ir & IR_ALL_INT)
 751                 m_can_write(priv, M_CAN_IR, ir);
 752
 753         /* schedule NAPI in case of
 754          * - rx IRQ
 755          * - state change IRQ
 756          * - bus error IRQ and bus error reporting
 757          */
 758         if ((ir & IR_RF0N) || (ir & IR_ERR_ALL)) {
 759                 priv->irqstatus = ir;
 760                 m_can_disable_all_interrupts(priv);
 761                 napi_schedule(&priv->napi);
 762         }
 763
 764         /* transmission complete interrupt */
 765         if (ir & IR_TC) {
 766                 stats->tx_bytes += can_get_echo_skb(dev, 0);
 767                 stats->tx_packets++;
 768                 can_led_event(dev, CAN_LED_EVENT_TX);
 769                 netif_wake_queue(dev);
 770         }
 771
 772         return IRQ_HANDLED;
 773 }
 774
 775 static const struct can_bittiming_const m_can_bittiming_const = {
 776         .name = KBUILD_MODNAME,
 777         .tseg1_min = 2,         /* Time segment 1 = prop_seg + phase_seg1 */
 778         .tseg1_max = 64,
 779         .tseg2_min = 1,         /* Time segment 2 = phase_seg2 */
 780         .tseg2_max = 16,
 781         .sjw_max = 16,
 782         .brp_min = 1,
 783         .brp_max = 1024,
 784         .brp_inc = 1,
 785 };
 786
 787 static const struct can_bittiming_const m_can_data_bittiming_const = {
 788         .name = KBUILD_MODNAME,
 789         .tseg1_min = 2,         /* Time segment 1 = prop_seg + phase_seg1 */
 790         .tseg1_max = 16,
 791         .tseg2_min = 1,         /* Time segment 2 = phase_seg2 */
 792         .tseg2_max = 8,
 793         .sjw_max = 4,
 794         .brp_min = 1,
 795         .brp_max = 32,
 796         .brp_inc = 1,
 797 };
 798
 799 static int m_can_set_bittiming(struct net_device *dev)
 800 {
 801         struct m_can_priv *priv = netdev_priv(dev);
 802         const struct can_bittiming *bt = &priv->can.bittiming;
 803         const struct can_bittiming *dbt = &priv->can.data_bittiming;
 804         u16 brp, sjw, tseg1, tseg2;
 805         u32 reg_btp;
 806
 807         brp = bt->brp - 1;
 808         sjw = bt->sjw - 1;
 809         tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
 810         tseg2 = bt->phase_seg2 - 1;
 811         reg_btp = (brp << BTR_BRP_SHIFT) | (sjw << BTR_SJW_SHIFT) |
 812                         (tseg1 << BTR_TSEG1_SHIFT) | (tseg2 << BTR_TSEG2_SHIFT);
 813         m_can_write(priv, M_CAN_BTP, reg_btp);
 814
 815         if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
 816                 brp = dbt->brp - 1;
 817                 sjw = dbt->sjw - 1;
 818                 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
 819                 tseg2 = dbt->phase_seg2 - 1;
 820                 reg_btp = (brp << FBTR_FBRP_SHIFT) | (sjw << FBTR_FSJW_SHIFT) |
 821                                 (tseg1 << FBTR_FTSEG1_SHIFT) |
 822                                 (tseg2 << FBTR_FTSEG2_SHIFT);
 823                 m_can_write(priv, M_CAN_FBTP, reg_btp);
 824         }
 825
 826         return 0;
 827 }
 828
 829 /* Configure M_CAN chip:
 830  * - set rx buffer/fifo element size
 831  * - configure rx fifo
 832  * - accept non-matching frame into fifo 0
 833  * - configure tx buffer
 834  * - configure mode
 835  * - setup bittiming
 836  */
 837 static void m_can_chip_config(struct net_device *dev)
 838 {
 839         struct m_can_priv *priv = netdev_priv(dev);
 840         u32 cccr, test;
 841
 842         m_can_config_endisable(priv, true);
 843
 844         /* RX Buffer/FIFO Element Size 64 bytes data field */
 845         m_can_write(priv, M_CAN_RXESC, M_CAN_RXESC_64BYTES);
 846
 847         /* Accept Non-matching Frames Into FIFO 0 */
 848         m_can_write(priv, M_CAN_GFC, 0x0);
 849
 850         /* only support one Tx Buffer currently */
 851         m_can_write(priv, M_CAN_TXBC, (1 << TXBC_NDTB_OFF) |
 852                     priv->mcfg[MRAM_TXB].off);
 853
 854         /* support 64 bytes payload */
 855         m_can_write(priv, M_CAN_TXESC, TXESC_TBDS_64BYTES);
 856
 857         m_can_write(priv, M_CAN_TXEFC, (1 << TXEFC_EFS_OFF) |
 858                     priv->mcfg[MRAM_TXE].off);
 859
 860         /* rx fifo configuration, blocking mode, fifo size 1 */
 861         m_can_write(priv, M_CAN_RXF0C,
 862                     (priv->mcfg[MRAM_RXF0].num << RXFC_FS_OFF) |
 863                     RXFC_FWM_1 | priv->mcfg[MRAM_RXF0].off);
 864
 865         m_can_write(priv, M_CAN_RXF1C,
 866                     (priv->mcfg[MRAM_RXF1].num << RXFC_FS_OFF) |
 867                     RXFC_FWM_1 | priv->mcfg[MRAM_RXF1].off);
 868
 869         cccr = m_can_read(priv, M_CAN_CCCR);
 870         cccr &= ~(CCCR_TEST | CCCR_MON | (CCCR_CMR_MASK << CCCR_CMR_SHIFT) |
 871                 (CCCR_CME_MASK << CCCR_CME_SHIFT));
 872         test = m_can_read(priv, M_CAN_TEST);
 873         test &= ~TEST_LBCK;
 874
 875         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 876                 cccr |= CCCR_MON;
 877
 878         if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
 879                 cccr |= CCCR_TEST;
 880                 test |= TEST_LBCK;
 881         }
 882
 883         if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
 884                 cccr |= CCCR_CME_CANFD_BRS << CCCR_CME_SHIFT;
 885
 886         m_can_write(priv, M_CAN_CCCR, cccr);
 887         m_can_write(priv, M_CAN_TEST, test);
 888
 889         /* enable interrupts */
 890         m_can_write(priv, M_CAN_IR, IR_ALL_INT);
 891         if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING))
 892                 m_can_write(priv, M_CAN_IE, IR_ALL_INT & ~IR_ERR_LEC);
 893         else
 894                 m_can_write(priv, M_CAN_IE, IR_ALL_INT);
 895
 896         /* route all interrupts to INT0 */
 897         m_can_write(priv, M_CAN_ILS, ILS_ALL_INT0);
 898
 899         /* set bittiming params */
 900         m_can_set_bittiming(dev);
 901
 902         m_can_config_endisable(priv, false);
 903 }
 904
 905 static void m_can_start(struct net_device *dev)
 906 {
 907         struct m_can_priv *priv = netdev_priv(dev);
 908
 909         /* basic m_can configuration */
 910         m_can_chip_config(dev);
 911
 912         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 913
 914         m_can_enable_all_interrupts(priv);
 915 }
 916
 917 static int m_can_set_mode(struct net_device *dev, enum can_mode mode)
 918 {
 919         switch (mode) {
 920         case CAN_MODE_START:
 921                 m_can_start(dev);
 922                 netif_wake_queue(dev);
 923                 break;
 924         default:
 925                 return -EOPNOTSUPP;
 926         }
 927
 928         return 0;
 929 }
 930
 931 static void free_m_can_dev(struct net_device *dev)
 932 {
 933         free_candev(dev);
 934 }
 935
 936 static struct net_device *alloc_m_can_dev(void)
 937 {
 938         struct net_device *dev;
 939         struct m_can_priv *priv;
 940
 941         dev = alloc_candev(sizeof(*priv), 1);
 942         if (!dev)
 943                 return NULL;
 944
 945         priv = netdev_priv(dev);
 946         netif_napi_add(dev, &priv->napi, m_can_poll, M_CAN_NAPI_WEIGHT);
 947
 948         priv->dev = dev;
 949         priv->can.bittiming_const = &m_can_bittiming_const;
 950         priv->can.data_bittiming_const = &m_can_data_bittiming_const;
 951         priv->can.do_set_mode = m_can_set_mode;
 952         priv->can.do_get_berr_counter = m_can_get_berr_counter;
 953
 954         /* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.0.1 */
 955         can_set_static_ctrlmode(dev, CAN_CTRLMODE_FD_NON_ISO);
 956
 957         /* CAN_CTRLMODE_FD_NON_ISO can not be changed with M_CAN IP v3.0.1 */
 958         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
 959                                         CAN_CTRLMODE_LISTENONLY |
 960                                         CAN_CTRLMODE_BERR_REPORTING |
 961                                         CAN_CTRLMODE_FD;
 962
 963         return dev;
 964 }
 965
 966 static int m_can_open(struct net_device *dev)
 967 {
 968         struct m_can_priv *priv = netdev_priv(dev);
 969         int err;
 970
 971         err = clk_prepare_enable(priv->hclk);
 972         if (err)
 973                 return err;
 974
 975         err = clk_prepare_enable(priv->cclk);
 976         if (err)
 977                 goto exit_disable_hclk;
 978
 979         /* open the can device */
 980         err = open_candev(dev);
 981         if (err) {
 982                 netdev_err(dev, "failed to open can device\n");
 983                 goto exit_disable_cclk;
 984         }
 985
 986         /* register interrupt handler */
 987         err = request_irq(dev->irq, m_can_isr, IRQF_SHARED, dev->name,
 988                           dev);
 989         if (err < 0) {
 990                 netdev_err(dev, "failed to request interrupt\n");
 991                 goto exit_irq_fail;
 992         }
 993
 994         /* start the m_can controller */
 995         m_can_start(dev);
 996
 997         can_led_event(dev, CAN_LED_EVENT_OPEN);
 998         napi_enable(&priv->napi);
 999         netif_start_queue(dev);
1000
1001         return 0;
1002
1003 exit_irq_fail:
1004         close_candev(dev);
1005 exit_disable_cclk:
1006         clk_disable_unprepare(priv->cclk);
1007 exit_disable_hclk:
1008         clk_disable_unprepare(priv->hclk);
1009         return err;
1010 }
1011
1012 static void m_can_stop(struct net_device *dev)
1013 {
1014         struct m_can_priv *priv = netdev_priv(dev);
1015
1016         /* disable all interrupts */
1017         m_can_disable_all_interrupts(priv);
1018
1019         clk_disable_unprepare(priv->hclk);
1020         clk_disable_unprepare(priv->cclk);
1021
1022         /* set the state as STOPPED */
1023         priv->can.state = CAN_STATE_STOPPED;
1024 }
1025
1026 static int m_can_close(struct net_device *dev)
1027 {
1028         struct m_can_priv *priv = netdev_priv(dev);
1029
1030         netif_stop_queue(dev);
1031         napi_disable(&priv->napi);
1032         m_can_stop(dev);
1033         free_irq(dev->irq, dev);
1034         close_candev(dev);
1035         can_led_event(dev, CAN_LED_EVENT_STOP);
1036
1037         return 0;
1038 }
1039
1040 static netdev_tx_t m_can_start_xmit(struct sk_buff *skb,
1041                                     struct net_device *dev)
1042 {
1043         struct m_can_priv *priv = netdev_priv(dev);
1044         struct canfd_frame *cf = (struct canfd_frame *)skb->data;
1045         u32 id, cccr;
1046         int i;
1047
1048         if (can_dropped_invalid_skb(dev, skb))
1049                 return NETDEV_TX_OK;
1050
1051         netif_stop_queue(dev);
1052
1053         if (cf->can_id & CAN_EFF_FLAG) {
1054                 id = cf->can_id & CAN_EFF_MASK;
1055                 id |= TX_BUF_XTD;
1056         } else {
1057                 id = ((cf->can_id & CAN_SFF_MASK) << 18);
1058         }
1059
1060         if (cf->can_id & CAN_RTR_FLAG)
1061                 id |= TX_BUF_RTR;
1062
1063         /* message ram configuration */
1064         m_can_fifo_write(priv, 0, M_CAN_FIFO_ID, id);
1065         m_can_fifo_write(priv, 0, M_CAN_FIFO_DLC, can_len2dlc(cf->len) << 16);
1066
1067         for (i = 0; i < cf->len; i += 4)
1068                 m_can_fifo_write(priv, 0, M_CAN_FIFO_DATA(i / 4),
1069                                  *(u32 *)(cf->data + i));
1070
1071         if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1072                 cccr = m_can_read(priv, M_CAN_CCCR);
1073                 cccr &= ~(CCCR_CMR_MASK << CCCR_CMR_SHIFT);
1074                 if (can_is_canfd_skb(skb)) {
1075                         if (cf->flags & CANFD_BRS)
1076                                 cccr |= CCCR_CMR_CANFD_BRS << CCCR_CMR_SHIFT;
1077                         else
1078                                 cccr |= CCCR_CMR_CANFD << CCCR_CMR_SHIFT;
1079                 } else {
1080                         cccr |= CCCR_CMR_CAN << CCCR_CMR_SHIFT;
1081                 }
1082                 m_can_write(priv, M_CAN_CCCR, cccr);
1083         }
1084
1085         /* enable first TX buffer to start transfer  */
1086         m_can_write(priv, M_CAN_TXBTIE, 0x1);
1087
1088         can_put_echo_skb(skb, dev, 0);
1089
1090         m_can_write(priv, M_CAN_TXBAR, 0x1);
1091
1092         return NETDEV_TX_OK;
1093 }
1094
1095 static const struct net_device_ops m_can_netdev_ops = {
1096         .ndo_open = m_can_open,
1097         .ndo_stop = m_can_close,
1098         .ndo_start_xmit = m_can_start_xmit,
1099         .ndo_change_mtu = can_change_mtu,
1100 };
1101
1102 static int register_m_can_dev(struct net_device *dev)
1103 {
1104         dev->flags |= IFF_ECHO; /* we support local echo */
1105         dev->netdev_ops = &m_can_netdev_ops;
1106
1107         return register_candev(dev);
1108 }
1109
1110 static int m_can_of_parse_mram(struct platform_device *pdev,
1111                                struct m_can_priv *priv)
1112 {
1113         struct device_node *np = pdev->dev.of_node;
1114         struct resource *res;
1115         void __iomem *addr;
1116         u32 out_val[MRAM_CFG_LEN];
1117         int i, start, end, ret;
1118
1119         /* message ram could be shared */
1120         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "message_ram");
1121         if (!res)
1122                 return -ENODEV;
1123
1124         addr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
1125         if (!addr)
1126                 return -ENOMEM;
1127
1128         /* get message ram configuration */
1129         ret = of_property_read_u32_array(np, "bosch,mram-cfg",
1130                                          out_val, sizeof(out_val) / 4);
1131         if (ret) {
1132                 dev_err(&pdev->dev, "can not get message ram configuration\n");
1133                 return -ENODEV;
1134         }
1135
1136         priv->mram_base = addr;
1137         priv->mcfg[MRAM_SIDF].off = out_val[0];
1138         priv->mcfg[MRAM_SIDF].num = out_val[1];
1139         priv->mcfg[MRAM_XIDF].off = priv->mcfg[MRAM_SIDF].off +
1140                         priv->mcfg[MRAM_SIDF].num * SIDF_ELEMENT_SIZE;
1141         priv->mcfg[MRAM_XIDF].num = out_val[2];
1142         priv->mcfg[MRAM_RXF0].off = priv->mcfg[MRAM_XIDF].off +
1143                         priv->mcfg[MRAM_XIDF].num * XIDF_ELEMENT_SIZE;
1144         priv->mcfg[MRAM_RXF0].num = out_val[3] & RXFC_FS_MASK;
1145         priv->mcfg[MRAM_RXF1].off = priv->mcfg[MRAM_RXF0].off +
1146                         priv->mcfg[MRAM_RXF0].num * RXF0_ELEMENT_SIZE;
1147         priv->mcfg[MRAM_RXF1].num = out_val[4] & RXFC_FS_MASK;
1148         priv->mcfg[MRAM_RXB].off = priv->mcfg[MRAM_RXF1].off +
1149                         priv->mcfg[MRAM_RXF1].num * RXF1_ELEMENT_SIZE;
1150         priv->mcfg[MRAM_RXB].num = out_val[5];
1151         priv->mcfg[MRAM_TXE].off = priv->mcfg[MRAM_RXB].off +
1152                         priv->mcfg[MRAM_RXB].num * RXB_ELEMENT_SIZE;
1153         priv->mcfg[MRAM_TXE].num = out_val[6];
1154         priv->mcfg[MRAM_TXB].off = priv->mcfg[MRAM_TXE].off +
1155                         priv->mcfg[MRAM_TXE].num * TXE_ELEMENT_SIZE;
1156         priv->mcfg[MRAM_TXB].num = out_val[7] & TXBC_NDTB_MASK;
1157
1158         dev_dbg(&pdev->dev, "mram_base %p sidf 0x%x %d xidf 0x%x %d rxf0 0x%x %d rxf1 0x%x %d rxb 0x%x %d txe 0x%x %d txb 0x%x %d\n",
1159                 priv->mram_base,
1160                 priv->mcfg[MRAM_SIDF].off, priv->mcfg[MRAM_SIDF].num,
1161                 priv->mcfg[MRAM_XIDF].off, priv->mcfg[MRAM_XIDF].num,
1162                 priv->mcfg[MRAM_RXF0].off, priv->mcfg[MRAM_RXF0].num,
1163                 priv->mcfg[MRAM_RXF1].off, priv->mcfg[MRAM_RXF1].num,
1164                 priv->mcfg[MRAM_RXB].off, priv->mcfg[MRAM_RXB].num,
1165                 priv->mcfg[MRAM_TXE].off, priv->mcfg[MRAM_TXE].num,
1166                 priv->mcfg[MRAM_TXB].off, priv->mcfg[MRAM_TXB].num);
1167
1168         /* initialize the entire Message RAM in use to avoid possible
1169          * ECC/parity checksum errors when reading an uninitialized buffer
1170          */
1171         start = priv->mcfg[MRAM_SIDF].off;
1172         end = priv->mcfg[MRAM_TXB].off +
1173                 priv->mcfg[MRAM_TXB].num * TXB_ELEMENT_SIZE;
1174         for (i = start; i < end; i += 4)
1175                 writel(0x0, priv->mram_base + i);
1176
1177         return 0;
1178 }
1179
1180 static int m_can_plat_probe(struct platform_device *pdev)
1181 {
1182         struct net_device *dev;
1183         struct m_can_priv *priv;
1184         struct resource *res;
1185         void __iomem *addr;
1186         struct clk *hclk, *cclk;
1187         int irq, ret;
1188
1189         hclk = devm_clk_get(&pdev->dev, "hclk");
1190         cclk = devm_clk_get(&pdev->dev, "cclk");
1191         if (IS_ERR(hclk) || IS_ERR(cclk)) {
1192                 dev_err(&pdev->dev, "no clock find\n");
1193                 return -ENODEV;
1194         }
1195
1196         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "m_can");
1197         addr = devm_ioremap_resource(&pdev->dev, res);
1198         irq = platform_get_irq_byname(pdev, "int0");
1199         if (IS_ERR(addr) || irq < 0)
1200                 return -EINVAL;
1201
1202         /* allocate the m_can device */
1203         dev = alloc_m_can_dev();
1204         if (!dev)
1205                 return -ENOMEM;
1206
1207         priv = netdev_priv(dev);
1208         dev->irq = irq;
1209         priv->base = addr;
1210         priv->device = &pdev->dev;
1211         priv->hclk = hclk;
1212         priv->cclk = cclk;
1213         priv->can.clock.freq = clk_get_rate(cclk);
1214
1215         ret = m_can_of_parse_mram(pdev, priv);
1216         if (ret)
1217                 goto failed_free_dev;
1218
1219         platform_set_drvdata(pdev, dev);
1220         SET_NETDEV_DEV(dev, &pdev->dev);
1221
1222         ret = register_m_can_dev(dev);
1223         if (ret) {
1224                 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
1225                         KBUILD_MODNAME, ret);
1226                 goto failed_free_dev;
1227         }
1228
1229         devm_can_led_init(dev);
1230
1231         dev_info(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
1232                  KBUILD_MODNAME, priv->base, dev->irq);
1233
1234         return 0;
1235
1236 failed_free_dev:
1237         free_m_can_dev(dev);
1238         return ret;
1239 }
1240
1241 static __maybe_unused int m_can_suspend(struct device *dev)
1242 {
1243         struct net_device *ndev = dev_get_drvdata(dev);
1244         struct m_can_priv *priv = netdev_priv(ndev);
1245
1246         if (netif_running(ndev)) {
1247                 netif_stop_queue(ndev);
1248                 netif_device_detach(ndev);
1249         }
1250
1251         /* TODO: enter low power */
1252
1253         priv->can.state = CAN_STATE_SLEEPING;
1254
1255         return 0;
1256 }
1257
1258 static __maybe_unused int m_can_resume(struct device *dev)
1259 {
1260         struct net_device *ndev = dev_get_drvdata(dev);
1261         struct m_can_priv *priv = netdev_priv(ndev);
1262
1263         /* TODO: exit low power */
1264
1265         priv->can.state = CAN_STATE_ERROR_ACTIVE;
1266
1267         if (netif_running(ndev)) {
1268                 netif_device_attach(ndev);
1269                 netif_start_queue(ndev);
1270         }
1271
1272         return 0;
1273 }
1274
1275 static void unregister_m_can_dev(struct net_device *dev)
1276 {
1277         unregister_candev(dev);
1278 }
1279
1280 static int m_can_plat_remove(struct platform_device *pdev)
1281 {
1282         struct net_device *dev = platform_get_drvdata(pdev);
1283
1284         unregister_m_can_dev(dev);
1285         platform_set_drvdata(pdev, NULL);
1286
1287         free_m_can_dev(dev);
1288
1289         return 0;
1290 }
1291
1292 static const struct dev_pm_ops m_can_pmops = {
1293         SET_SYSTEM_SLEEP_PM_OPS(m_can_suspend, m_can_resume)
1294 };
1295
1296 static const struct of_device_id m_can_of_table[] = {
1297         { .compatible = "bosch,m_can", .data = NULL },
1298         { /* sentinel */ },
1299 };
1300 MODULE_DEVICE_TABLE(of, m_can_of_table);
1301
1302 static struct platform_driver m_can_plat_driver = {
1303         .driver = {
1304                 .name = KBUILD_MODNAME,
1305                 .of_match_table = m_can_of_table,
1306                 .pm     = &m_can_pmops,
1307         },
1308         .probe = m_can_plat_probe,
1309         .remove = m_can_plat_remove,
1310 };
1311
1312 module_platform_driver(m_can_plat_driver);
1313
1314 MODULE_AUTHOR("Dong Aisheng <b29396@freescale.com>");
1315 MODULE_LICENSE("GPL v2");
1316 MODULE_DESCRIPTION("CAN bus driver for Bosch M_CAN controller");