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 #include <linux/pm_runtime.h>
  27 #include <linux/iopoll.h>
  28 #include <linux/can/dev.h>
  29 #include <linux/pinctrl/consumer.h>
  30
  31 /* napi related */
  32 #define M_CAN_NAPI_WEIGHT       64
  33
  34 /* message ram configuration data length */
  35 #define MRAM_CFG_LEN    8
  36
  37 /* registers definition */
  38 enum m_can_reg {
  39         M_CAN_CREL      = 0x0,
  40         M_CAN_ENDN      = 0x4,
  41         M_CAN_CUST      = 0x8,
  42         M_CAN_DBTP      = 0xc,
  43         M_CAN_TEST      = 0x10,
  44         M_CAN_RWD       = 0x14,
  45         M_CAN_CCCR      = 0x18,
  46         M_CAN_NBTP      = 0x1c,
  47         M_CAN_TSCC      = 0x20,
  48         M_CAN_TSCV      = 0x24,
  49         M_CAN_TOCC      = 0x28,
  50         M_CAN_TOCV      = 0x2c,
  51         M_CAN_ECR       = 0x40,
  52         M_CAN_PSR       = 0x44,
  53 /* TDCR Register only available for version >=3.1.x */
  54         M_CAN_TDCR      = 0x48,
  55         M_CAN_IR        = 0x50,
  56         M_CAN_IE        = 0x54,
  57         M_CAN_ILS       = 0x58,
  58         M_CAN_ILE       = 0x5c,
  59         M_CAN_GFC       = 0x80,
  60         M_CAN_SIDFC     = 0x84,
  61         M_CAN_XIDFC     = 0x88,
  62         M_CAN_XIDAM     = 0x90,
  63         M_CAN_HPMS      = 0x94,
  64         M_CAN_NDAT1     = 0x98,
  65         M_CAN_NDAT2     = 0x9c,
  66         M_CAN_RXF0C     = 0xa0,
  67         M_CAN_RXF0S     = 0xa4,
  68         M_CAN_RXF0A     = 0xa8,
  69         M_CAN_RXBC      = 0xac,
  70         M_CAN_RXF1C     = 0xb0,
  71         M_CAN_RXF1S     = 0xb4,
  72         M_CAN_RXF1A     = 0xb8,
  73         M_CAN_RXESC     = 0xbc,
  74         M_CAN_TXBC      = 0xc0,
  75         M_CAN_TXFQS     = 0xc4,
  76         M_CAN_TXESC     = 0xc8,
  77         M_CAN_TXBRP     = 0xcc,
  78         M_CAN_TXBAR     = 0xd0,
  79         M_CAN_TXBCR     = 0xd4,
  80         M_CAN_TXBTO     = 0xd8,
  81         M_CAN_TXBCF     = 0xdc,
  82         M_CAN_TXBTIE    = 0xe0,
  83         M_CAN_TXBCIE    = 0xe4,
  84         M_CAN_TXEFC     = 0xf0,
  85         M_CAN_TXEFS     = 0xf4,
  86         M_CAN_TXEFA     = 0xf8,
  87 };
  88
  89 /* m_can lec values */
  90 enum m_can_lec_type {
  91         LEC_NO_ERROR = 0,
  92         LEC_STUFF_ERROR,
  93         LEC_FORM_ERROR,
  94         LEC_ACK_ERROR,
  95         LEC_BIT1_ERROR,
  96         LEC_BIT0_ERROR,
  97         LEC_CRC_ERROR,
  98         LEC_UNUSED,
  99 };
 100
 101 enum m_can_mram_cfg {
 102         MRAM_SIDF = 0,
 103         MRAM_XIDF,
 104         MRAM_RXF0,
 105         MRAM_RXF1,
 106         MRAM_RXB,
 107         MRAM_TXE,
 108         MRAM_TXB,
 109         MRAM_CFG_NUM,
 110 };
 111
 112 /* Core Release Register (CREL) */
 113 #define CREL_REL_SHIFT          28
 114 #define CREL_REL_MASK           (0xF << CREL_REL_SHIFT)
 115 #define CREL_STEP_SHIFT         24
 116 #define CREL_STEP_MASK          (0xF << CREL_STEP_SHIFT)
 117 #define CREL_SUBSTEP_SHIFT      20
 118 #define CREL_SUBSTEP_MASK       (0xF << CREL_SUBSTEP_SHIFT)
 119
 120 /* Data Bit Timing & Prescaler Register (DBTP) */
 121 #define DBTP_TDC                BIT(23)
 122 #define DBTP_DBRP_SHIFT         16
 123 #define DBTP_DBRP_MASK          (0x1f << DBTP_DBRP_SHIFT)
 124 #define DBTP_DTSEG1_SHIFT       8
 125 #define DBTP_DTSEG1_MASK        (0x1f << DBTP_DTSEG1_SHIFT)
 126 #define DBTP_DTSEG2_SHIFT       4
 127 #define DBTP_DTSEG2_MASK        (0xf << DBTP_DTSEG2_SHIFT)
 128 #define DBTP_DSJW_SHIFT         0
 129 #define DBTP_DSJW_MASK          (0xf << DBTP_DSJW_SHIFT)
 130
 131 /* Transmitter Delay Compensation Register (TDCR) */
 132 #define TDCR_TDCO_SHIFT         8
 133 #define TDCR_TDCO_MASK          (0x7F << TDCR_TDCO_SHIFT)
 134 #define TDCR_TDCF_SHIFT         0
 135 #define TDCR_TDCF_MASK          (0x7F << TDCR_TDCF_SHIFT)
 136
 137 /* Test Register (TEST) */
 138 #define TEST_LBCK               BIT(4)
 139
 140 /* CC Control Register(CCCR) */
 141 #define CCCR_CMR_MASK           0x3
 142 #define CCCR_CMR_SHIFT          10
 143 #define CCCR_CMR_CANFD          0x1
 144 #define CCCR_CMR_CANFD_BRS      0x2
 145 #define CCCR_CMR_CAN            0x3
 146 #define CCCR_CME_MASK           0x3
 147 #define CCCR_CME_SHIFT          8
 148 #define CCCR_CME_CAN            0
 149 #define CCCR_CME_CANFD          0x1
 150 #define CCCR_CME_CANFD_BRS      0x2
 151 #define CCCR_TXP                BIT(14)
 152 #define CCCR_TEST               BIT(7)
 153 #define CCCR_MON                BIT(5)
 154 #define CCCR_CSR                BIT(4)
 155 #define CCCR_CSA                BIT(3)
 156 #define CCCR_ASM                BIT(2)
 157 #define CCCR_CCE                BIT(1)
 158 #define CCCR_INIT               BIT(0)
 159 #define CCCR_CANFD              0x10
 160 /* for version >=3.1.x */
 161 #define CCCR_EFBI               BIT(13)
 162 #define CCCR_PXHD               BIT(12)
 163 #define CCCR_BRSE               BIT(9)
 164 #define CCCR_FDOE               BIT(8)
 165 /* only for version >=3.2.x */
 166 #define CCCR_NISO               BIT(15)
 167
 168 /* Nominal Bit Timing & Prescaler Register (NBTP) */
 169 #define NBTP_NSJW_SHIFT         25
 170 #define NBTP_NSJW_MASK          (0x7f << NBTP_NSJW_SHIFT)
 171 #define NBTP_NBRP_SHIFT         16
 172 #define NBTP_NBRP_MASK          (0x1ff << NBTP_NBRP_SHIFT)
 173 #define NBTP_NTSEG1_SHIFT       8
 174 #define NBTP_NTSEG1_MASK        (0xff << NBTP_NTSEG1_SHIFT)
 175 #define NBTP_NTSEG2_SHIFT       0
 176 #define NBTP_NTSEG2_MASK        (0x7f << NBTP_NTSEG2_SHIFT)
 177
 178 /* Error Counter Register(ECR) */
 179 #define ECR_RP                  BIT(15)
 180 #define ECR_REC_SHIFT           8
 181 #define ECR_REC_MASK            (0x7f << ECR_REC_SHIFT)
 182 #define ECR_TEC_SHIFT           0
 183 #define ECR_TEC_MASK            0xff
 184
 185 /* Protocol Status Register(PSR) */
 186 #define PSR_BO          BIT(7)
 187 #define PSR_EW          BIT(6)
 188 #define PSR_EP          BIT(5)
 189 #define PSR_LEC_MASK    0x7
 190
 191 /* Interrupt Register(IR) */
 192 #define IR_ALL_INT      0xffffffff
 193
 194 /* Renamed bits for versions > 3.1.x */
 195 #define IR_ARA          BIT(29)
 196 #define IR_PED          BIT(28)
 197 #define IR_PEA          BIT(27)
 198
 199 /* Bits for version 3.0.x */
 200 #define IR_STE          BIT(31)
 201 #define IR_FOE          BIT(30)
 202 #define IR_ACKE         BIT(29)
 203 #define IR_BE           BIT(28)
 204 #define IR_CRCE         BIT(27)
 205 #define IR_WDI          BIT(26)
 206 #define IR_BO           BIT(25)
 207 #define IR_EW           BIT(24)
 208 #define IR_EP           BIT(23)
 209 #define IR_ELO          BIT(22)
 210 #define IR_BEU          BIT(21)
 211 #define IR_BEC          BIT(20)
 212 #define IR_DRX          BIT(19)
 213 #define IR_TOO          BIT(18)
 214 #define IR_MRAF         BIT(17)
 215 #define IR_TSW          BIT(16)
 216 #define IR_TEFL         BIT(15)
 217 #define IR_TEFF         BIT(14)
 218 #define IR_TEFW         BIT(13)
 219 #define IR_TEFN         BIT(12)
 220 #define IR_TFE          BIT(11)
 221 #define IR_TCF          BIT(10)
 222 #define IR_TC           BIT(9)
 223 #define IR_HPM          BIT(8)
 224 #define IR_RF1L         BIT(7)
 225 #define IR_RF1F         BIT(6)
 226 #define IR_RF1W         BIT(5)
 227 #define IR_RF1N         BIT(4)
 228 #define IR_RF0L         BIT(3)
 229 #define IR_RF0F         BIT(2)
 230 #define IR_RF0W         BIT(1)
 231 #define IR_RF0N         BIT(0)
 232 #define IR_ERR_STATE    (IR_BO | IR_EW | IR_EP)
 233
 234 /* Interrupts for version 3.0.x */
 235 #define IR_ERR_LEC_30X  (IR_STE | IR_FOE | IR_ACKE | IR_BE | IR_CRCE)
 236 #define IR_ERR_BUS_30X  (IR_ERR_LEC_30X | IR_WDI | IR_BEU | IR_BEC | \
 237                          IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | IR_RF1L | \
 238                          IR_RF0L)
 239 #define IR_ERR_ALL_30X  (IR_ERR_STATE | IR_ERR_BUS_30X)
 240 /* Interrupts for version >= 3.1.x */
 241 #define IR_ERR_LEC_31X  (IR_PED | IR_PEA)
 242 #define IR_ERR_BUS_31X      (IR_ERR_LEC_31X | IR_WDI | IR_BEU | IR_BEC | \
 243                          IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | IR_RF1L | \
 244                          IR_RF0L)
 245 #define IR_ERR_ALL_31X  (IR_ERR_STATE | IR_ERR_BUS_31X)
 246
 247 /* Interrupt Line Select (ILS) */
 248 #define ILS_ALL_INT0    0x0
 249 #define ILS_ALL_INT1    0xFFFFFFFF
 250
 251 /* Interrupt Line Enable (ILE) */
 252 #define ILE_EINT1       BIT(1)
 253 #define ILE_EINT0       BIT(0)
 254
 255 /* Rx FIFO 0/1 Configuration (RXF0C/RXF1C) */
 256 #define RXFC_FWM_SHIFT  24
 257 #define RXFC_FWM_MASK   (0x7f << RXFC_FWM_SHIFT)
 258 #define RXFC_FS_SHIFT   16
 259 #define RXFC_FS_MASK    (0x7f << RXFC_FS_SHIFT)
 260
 261 /* Rx FIFO 0/1 Status (RXF0S/RXF1S) */
 262 #define RXFS_RFL        BIT(25)
 263 #define RXFS_FF         BIT(24)
 264 #define RXFS_FPI_SHIFT  16
 265 #define RXFS_FPI_MASK   0x3f0000
 266 #define RXFS_FGI_SHIFT  8
 267 #define RXFS_FGI_MASK   0x3f00
 268 #define RXFS_FFL_MASK   0x7f
 269
 270 /* Rx Buffer / FIFO Element Size Configuration (RXESC) */
 271 #define M_CAN_RXESC_8BYTES      0x0
 272 #define M_CAN_RXESC_64BYTES     0x777
 273
 274 /* Tx Buffer Configuration(TXBC) */
 275 #define TXBC_NDTB_SHIFT         16
 276 #define TXBC_NDTB_MASK          (0x3f << TXBC_NDTB_SHIFT)
 277 #define TXBC_TFQS_SHIFT         24
 278 #define TXBC_TFQS_MASK          (0x3f << TXBC_TFQS_SHIFT)
 279
 280 /* Tx FIFO/Queue Status (TXFQS) */
 281 #define TXFQS_TFQF              BIT(21)
 282 #define TXFQS_TFQPI_SHIFT       16
 283 #define TXFQS_TFQPI_MASK        (0x1f << TXFQS_TFQPI_SHIFT)
 284 #define TXFQS_TFGI_SHIFT        8
 285 #define TXFQS_TFGI_MASK         (0x1f << TXFQS_TFGI_SHIFT)
 286 #define TXFQS_TFFL_SHIFT        0
 287 #define TXFQS_TFFL_MASK         (0x3f << TXFQS_TFFL_SHIFT)
 288
 289 /* Tx Buffer Element Size Configuration(TXESC) */
 290 #define TXESC_TBDS_8BYTES       0x0
 291 #define TXESC_TBDS_64BYTES      0x7
 292
 293 /* Tx Event FIFO Configuration (TXEFC) */
 294 #define TXEFC_EFS_SHIFT         16
 295 #define TXEFC_EFS_MASK          (0x3f << TXEFC_EFS_SHIFT)
 296
 297 /* Tx Event FIFO Status (TXEFS) */
 298 #define TXEFS_TEFL              BIT(25)
 299 #define TXEFS_EFF               BIT(24)
 300 #define TXEFS_EFGI_SHIFT        8
 301 #define TXEFS_EFGI_MASK         (0x1f << TXEFS_EFGI_SHIFT)
 302 #define TXEFS_EFFL_SHIFT        0
 303 #define TXEFS_EFFL_MASK         (0x3f << TXEFS_EFFL_SHIFT)
 304
 305 /* Tx Event FIFO Acknowledge (TXEFA) */
 306 #define TXEFA_EFAI_SHIFT        0
 307 #define TXEFA_EFAI_MASK         (0x1f << TXEFA_EFAI_SHIFT)
 308
 309 /* Message RAM Configuration (in bytes) */
 310 #define SIDF_ELEMENT_SIZE       4
 311 #define XIDF_ELEMENT_SIZE       8
 312 #define RXF0_ELEMENT_SIZE       72
 313 #define RXF1_ELEMENT_SIZE       72
 314 #define RXB_ELEMENT_SIZE        72
 315 #define TXE_ELEMENT_SIZE        8
 316 #define TXB_ELEMENT_SIZE        72
 317
 318 /* Message RAM Elements */
 319 #define M_CAN_FIFO_ID           0x0
 320 #define M_CAN_FIFO_DLC          0x4
 321 #define M_CAN_FIFO_DATA(n)      (0x8 + ((n) << 2))
 322
 323 /* Rx Buffer Element */
 324 /* R0 */
 325 #define RX_BUF_ESI              BIT(31)
 326 #define RX_BUF_XTD              BIT(30)
 327 #define RX_BUF_RTR              BIT(29)
 328 /* R1 */
 329 #define RX_BUF_ANMF             BIT(31)
 330 #define RX_BUF_FDF              BIT(21)
 331 #define RX_BUF_BRS              BIT(20)
 332
 333 /* Tx Buffer Element */
 334 /* T0 */
 335 #define TX_BUF_ESI              BIT(31)
 336 #define TX_BUF_XTD              BIT(30)
 337 #define TX_BUF_RTR              BIT(29)
 338 /* T1 */
 339 #define TX_BUF_EFC              BIT(23)
 340 #define TX_BUF_FDF              BIT(21)
 341 #define TX_BUF_BRS              BIT(20)
 342 #define TX_BUF_MM_SHIFT         24
 343 #define TX_BUF_MM_MASK          (0xff << TX_BUF_MM_SHIFT)
 344
 345 /* Tx event FIFO Element */
 346 /* E1 */
 347 #define TX_EVENT_MM_SHIFT       TX_BUF_MM_SHIFT
 348 #define TX_EVENT_MM_MASK        (0xff << TX_EVENT_MM_SHIFT)
 349
 350 /* address offset and element number for each FIFO/Buffer in the Message RAM */
 351 struct mram_cfg {
 352         u16 off;
 353         u8  num;
 354 };
 355
 356 /* m_can private data structure */
 357 struct m_can_priv {
 358         struct can_priv can;    /* must be the first member */
 359         struct napi_struct napi;
 360         struct net_device *dev;
 361         struct device *device;
 362         struct clk *hclk;
 363         struct clk *cclk;
 364         void __iomem *base;
 365         u32 irqstatus;
 366         int version;
 367
 368         /* message ram configuration */
 369         void __iomem *mram_base;
 370         struct mram_cfg mcfg[MRAM_CFG_NUM];
 371 };
 372
 373 static inline u32 m_can_read(const struct m_can_priv *priv, enum m_can_reg reg)
 374 {
 375         return readl(priv->base + reg);
 376 }
 377
 378 static inline void m_can_write(const struct m_can_priv *priv,
 379                                enum m_can_reg reg, u32 val)
 380 {
 381         writel(val, priv->base + reg);
 382 }
 383
 384 static inline u32 m_can_fifo_read(const struct m_can_priv *priv,
 385                                   u32 fgi, unsigned int offset)
 386 {
 387         return readl(priv->mram_base + priv->mcfg[MRAM_RXF0].off +
 388                      fgi * RXF0_ELEMENT_SIZE + offset);
 389 }
 390
 391 static inline void m_can_fifo_write(const struct m_can_priv *priv,
 392                                     u32 fpi, unsigned int offset, u32 val)
 393 {
 394         writel(val, priv->mram_base + priv->mcfg[MRAM_TXB].off +
 395                fpi * TXB_ELEMENT_SIZE + offset);
 396 }
 397
 398 static inline u32 m_can_txe_fifo_read(const struct m_can_priv *priv,
 399                                       u32 fgi,
 400                                       u32 offset) {
 401         return readl(priv->mram_base + priv->mcfg[MRAM_TXE].off +
 402                         fgi * TXE_ELEMENT_SIZE + offset);
 403 }
 404
 405 static inline bool m_can_tx_fifo_full(const struct m_can_priv *priv)
 406 {
 407                 return !!(m_can_read(priv, M_CAN_TXFQS) & TXFQS_TFQF);
 408 }
 409
 410 static inline void m_can_config_endisable(const struct m_can_priv *priv,
 411                                           bool enable)
 412 {
 413         u32 cccr = m_can_read(priv, M_CAN_CCCR);
 414         u32 timeout = 10;
 415         u32 val = 0;
 416
 417         if (enable) {
 418                 /* enable m_can configuration */
 419                 m_can_write(priv, M_CAN_CCCR, cccr | CCCR_INIT);
 420                 udelay(5);
 421                 /* CCCR.CCE can only be set/reset while CCCR.INIT = '1' */
 422                 m_can_write(priv, M_CAN_CCCR, cccr | CCCR_INIT | CCCR_CCE);
 423         } else {
 424                 m_can_write(priv, M_CAN_CCCR, cccr & ~(CCCR_INIT | CCCR_CCE));
 425         }
 426
 427         /* there's a delay for module initialization */
 428         if (enable)
 429                 val = CCCR_INIT | CCCR_CCE;
 430
 431         while ((m_can_read(priv, M_CAN_CCCR) & (CCCR_INIT | CCCR_CCE)) != val) {
 432                 if (timeout == 0) {
 433                         netdev_warn(priv->dev, "Failed to init module\n");
 434                         return;
 435                 }
 436                 timeout--;
 437                 udelay(1);
 438         }
 439 }
 440
 441 static inline void m_can_enable_all_interrupts(const struct m_can_priv *priv)
 442 {
 443         /* Only interrupt line 0 is used in this driver */
 444         m_can_write(priv, M_CAN_ILE, ILE_EINT0);
 445 }
 446
 447 static inline void m_can_disable_all_interrupts(const struct m_can_priv *priv)
 448 {
 449         m_can_write(priv, M_CAN_ILE, 0x0);
 450 }
 451
 452 static void m_can_read_fifo(struct net_device *dev, u32 rxfs)
 453 {
 454         struct net_device_stats *stats = &dev->stats;
 455         struct m_can_priv *priv = netdev_priv(dev);
 456         struct canfd_frame *cf;
 457         struct sk_buff *skb;
 458         u32 id, fgi, dlc;
 459         int i;
 460
 461         /* calculate the fifo get index for where to read data */
 462         fgi = (rxfs & RXFS_FGI_MASK) >> RXFS_FGI_SHIFT;
 463         dlc = m_can_fifo_read(priv, fgi, M_CAN_FIFO_DLC);
 464         if (dlc & RX_BUF_FDF)
 465                 skb = alloc_canfd_skb(dev, &cf);
 466         else
 467                 skb = alloc_can_skb(dev, (struct can_frame **)&cf);
 468         if (!skb) {
 469                 stats->rx_dropped++;
 470                 return;
 471         }
 472
 473         if (dlc & RX_BUF_FDF)
 474                 cf->len = can_dlc2len((dlc >> 16) & 0x0F);
 475         else
 476                 cf->len = get_can_dlc((dlc >> 16) & 0x0F);
 477
 478         id = m_can_fifo_read(priv, fgi, M_CAN_FIFO_ID);
 479         if (id & RX_BUF_XTD)
 480                 cf->can_id = (id & CAN_EFF_MASK) | CAN_EFF_FLAG;
 481         else
 482                 cf->can_id = (id >> 18) & CAN_SFF_MASK;
 483
 484         if (id & RX_BUF_ESI) {
 485                 cf->flags |= CANFD_ESI;
 486                 netdev_dbg(dev, "ESI Error\n");
 487         }
 488
 489         if (!(dlc & RX_BUF_FDF) && (id & RX_BUF_RTR)) {
 490                 cf->can_id |= CAN_RTR_FLAG;
 491         } else {
 492                 if (dlc & RX_BUF_BRS)
 493                         cf->flags |= CANFD_BRS;
 494
 495                 for (i = 0; i < cf->len; i += 4)
 496                         *(u32 *)(cf->data + i) =
 497                                 m_can_fifo_read(priv, fgi,
 498                                                 M_CAN_FIFO_DATA(i / 4));
 499         }
 500
 501         /* acknowledge rx fifo 0 */
 502         m_can_write(priv, M_CAN_RXF0A, fgi);
 503
 504         stats->rx_packets++;
 505         stats->rx_bytes += cf->len;
 506
 507         netif_receive_skb(skb);
 508 }
 509
 510 static int m_can_do_rx_poll(struct net_device *dev, int quota)
 511 {
 512         struct m_can_priv *priv = netdev_priv(dev);
 513         u32 pkts = 0;
 514         u32 rxfs;
 515
 516         rxfs = m_can_read(priv, M_CAN_RXF0S);
 517         if (!(rxfs & RXFS_FFL_MASK)) {
 518                 netdev_dbg(dev, "no messages in fifo0\n");
 519                 return 0;
 520         }
 521
 522         while ((rxfs & RXFS_FFL_MASK) && (quota > 0)) {
 523                 m_can_read_fifo(dev, rxfs);
 524
 525                 quota--;
 526                 pkts++;
 527                 rxfs = m_can_read(priv, M_CAN_RXF0S);
 528         }
 529
 530         if (pkts)
 531                 can_led_event(dev, CAN_LED_EVENT_RX);
 532
 533         return pkts;
 534 }
 535
 536 static int m_can_handle_lost_msg(struct net_device *dev)
 537 {
 538         struct net_device_stats *stats = &dev->stats;
 539         struct sk_buff *skb;
 540         struct can_frame *frame;
 541
 542         netdev_err(dev, "msg lost in rxf0\n");
 543
 544         stats->rx_errors++;
 545         stats->rx_over_errors++;
 546
 547         skb = alloc_can_err_skb(dev, &frame);
 548         if (unlikely(!skb))
 549                 return 0;
 550
 551         frame->can_id |= CAN_ERR_CRTL;
 552         frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 553
 554         netif_receive_skb(skb);
 555
 556         return 1;
 557 }
 558
 559 static int m_can_handle_lec_err(struct net_device *dev,
 560                                 enum m_can_lec_type lec_type)
 561 {
 562         struct m_can_priv *priv = netdev_priv(dev);
 563         struct net_device_stats *stats = &dev->stats;
 564         struct can_frame *cf;
 565         struct sk_buff *skb;
 566
 567         priv->can.can_stats.bus_error++;
 568         stats->rx_errors++;
 569
 570         /* propagate the error condition to the CAN stack */
 571         skb = alloc_can_err_skb(dev, &cf);
 572         if (unlikely(!skb))
 573                 return 0;
 574
 575         /* check for 'last error code' which tells us the
 576          * type of the last error to occur on the CAN bus
 577          */
 578         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 579
 580         switch (lec_type) {
 581         case LEC_STUFF_ERROR:
 582                 netdev_dbg(dev, "stuff error\n");
 583                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 584                 break;
 585         case LEC_FORM_ERROR:
 586                 netdev_dbg(dev, "form error\n");
 587                 cf->data[2] |= CAN_ERR_PROT_FORM;
 588                 break;
 589         case LEC_ACK_ERROR:
 590                 netdev_dbg(dev, "ack error\n");
 591                 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
 592                 break;
 593         case LEC_BIT1_ERROR:
 594                 netdev_dbg(dev, "bit1 error\n");
 595                 cf->data[2] |= CAN_ERR_PROT_BIT1;
 596                 break;
 597         case LEC_BIT0_ERROR:
 598                 netdev_dbg(dev, "bit0 error\n");
 599                 cf->data[2] |= CAN_ERR_PROT_BIT0;
 600                 break;
 601         case LEC_CRC_ERROR:
 602                 netdev_dbg(dev, "CRC error\n");
 603                 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
 604                 break;
 605         default:
 606                 break;
 607         }
 608
 609         stats->rx_packets++;
 610         stats->rx_bytes += cf->can_dlc;
 611         netif_receive_skb(skb);
 612
 613         return 1;
 614 }
 615
 616 static int __m_can_get_berr_counter(const struct net_device *dev,
 617                                     struct can_berr_counter *bec)
 618 {
 619         struct m_can_priv *priv = netdev_priv(dev);
 620         unsigned int ecr;
 621
 622         ecr = m_can_read(priv, M_CAN_ECR);
 623         bec->rxerr = (ecr & ECR_REC_MASK) >> ECR_REC_SHIFT;
 624         bec->txerr = (ecr & ECR_TEC_MASK) >> ECR_TEC_SHIFT;
 625
 626         return 0;
 627 }
 628
 629 static int m_can_clk_start(struct m_can_priv *priv)
 630 {
 631         int err;
 632
 633         err = pm_runtime_get_sync(priv->device);
 634         if (err < 0) {
 635                 pm_runtime_put_noidle(priv->device);
 636                 return err;
 637         }
 638
 639         return 0;
 640 }
 641
 642 static void m_can_clk_stop(struct m_can_priv *priv)
 643 {
 644         pm_runtime_put_sync(priv->device);
 645 }
 646
 647 static int m_can_get_berr_counter(const struct net_device *dev,
 648                                   struct can_berr_counter *bec)
 649 {
 650         struct m_can_priv *priv = netdev_priv(dev);
 651         int err;
 652
 653         err = m_can_clk_start(priv);
 654         if (err)
 655                 return err;
 656
 657         __m_can_get_berr_counter(dev, bec);
 658
 659         m_can_clk_stop(priv);
 660
 661         return 0;
 662 }
 663
 664 static int m_can_handle_state_change(struct net_device *dev,
 665                                      enum can_state new_state)
 666 {
 667         struct m_can_priv *priv = netdev_priv(dev);
 668         struct net_device_stats *stats = &dev->stats;
 669         struct can_frame *cf;
 670         struct sk_buff *skb;
 671         struct can_berr_counter bec;
 672         unsigned int ecr;
 673
 674         switch (new_state) {
 675         case CAN_STATE_ERROR_WARNING:
 676                 /* error warning state */
 677                 priv->can.can_stats.error_warning++;
 678                 priv->can.state = CAN_STATE_ERROR_WARNING;
 679                 break;
 680         case CAN_STATE_ERROR_PASSIVE:
 681                 /* error passive state */
 682                 priv->can.can_stats.error_passive++;
 683                 priv->can.state = CAN_STATE_ERROR_PASSIVE;
 684                 break;
 685         case CAN_STATE_BUS_OFF:
 686                 /* bus-off state */
 687                 priv->can.state = CAN_STATE_BUS_OFF;
 688                 m_can_disable_all_interrupts(priv);
 689                 priv->can.can_stats.bus_off++;
 690                 can_bus_off(dev);
 691                 break;
 692         default:
 693                 break;
 694         }
 695
 696         /* propagate the error condition to the CAN stack */
 697         skb = alloc_can_err_skb(dev, &cf);
 698         if (unlikely(!skb))
 699                 return 0;
 700
 701         __m_can_get_berr_counter(dev, &bec);
 702
 703         switch (new_state) {
 704         case CAN_STATE_ERROR_WARNING:
 705                 /* error warning state */
 706                 cf->can_id |= CAN_ERR_CRTL;
 707                 cf->data[1] = (bec.txerr > bec.rxerr) ?
 708                         CAN_ERR_CRTL_TX_WARNING :
 709                         CAN_ERR_CRTL_RX_WARNING;
 710                 cf->data[6] = bec.txerr;
 711                 cf->data[7] = bec.rxerr;
 712                 break;
 713         case CAN_STATE_ERROR_PASSIVE:
 714                 /* error passive state */
 715                 cf->can_id |= CAN_ERR_CRTL;
 716                 ecr = m_can_read(priv, M_CAN_ECR);
 717                 if (ecr & ECR_RP)
 718                         cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
 719                 if (bec.txerr > 127)
 720                         cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
 721                 cf->data[6] = bec.txerr;
 722                 cf->data[7] = bec.rxerr;
 723                 break;
 724         case CAN_STATE_BUS_OFF:
 725                 /* bus-off state */
 726                 cf->can_id |= CAN_ERR_BUSOFF;
 727                 break;
 728         default:
 729                 break;
 730         }
 731
 732         stats->rx_packets++;
 733         stats->rx_bytes += cf->can_dlc;
 734         netif_receive_skb(skb);
 735
 736         return 1;
 737 }
 738
 739 static int m_can_handle_state_errors(struct net_device *dev, u32 psr)
 740 {
 741         struct m_can_priv *priv = netdev_priv(dev);
 742         int work_done = 0;
 743
 744         if ((psr & PSR_EW) &&
 745             (priv->can.state != CAN_STATE_ERROR_WARNING)) {
 746                 netdev_dbg(dev, "entered error warning state\n");
 747                 work_done += m_can_handle_state_change(dev,
 748                                                        CAN_STATE_ERROR_WARNING);
 749         }
 750
 751         if ((psr & PSR_EP) &&
 752             (priv->can.state != CAN_STATE_ERROR_PASSIVE)) {
 753                 netdev_dbg(dev, "entered error passive state\n");
 754                 work_done += m_can_handle_state_change(dev,
 755                                                        CAN_STATE_ERROR_PASSIVE);
 756         }
 757
 758         if ((psr & PSR_BO) &&
 759             (priv->can.state != CAN_STATE_BUS_OFF)) {
 760                 netdev_dbg(dev, "entered error bus off state\n");
 761                 work_done += m_can_handle_state_change(dev,
 762                                                        CAN_STATE_BUS_OFF);
 763         }
 764
 765         return work_done;
 766 }
 767
 768 static void m_can_handle_other_err(struct net_device *dev, u32 irqstatus)
 769 {
 770         if (irqstatus & IR_WDI)
 771                 netdev_err(dev, "Message RAM Watchdog event due to missing READY\n");
 772         if (irqstatus & IR_BEU)
 773                 netdev_err(dev, "Bit Error Uncorrected\n");
 774         if (irqstatus & IR_BEC)
 775                 netdev_err(dev, "Bit Error Corrected\n");
 776         if (irqstatus & IR_TOO)
 777                 netdev_err(dev, "Timeout reached\n");
 778         if (irqstatus & IR_MRAF)
 779                 netdev_err(dev, "Message RAM access failure occurred\n");
 780 }
 781
 782 static inline bool is_lec_err(u32 psr)
 783 {
 784         psr &= LEC_UNUSED;
 785
 786         return psr && (psr != LEC_UNUSED);
 787 }
 788
 789 static int m_can_handle_bus_errors(struct net_device *dev, u32 irqstatus,
 790                                    u32 psr)
 791 {
 792         struct m_can_priv *priv = netdev_priv(dev);
 793         int work_done = 0;
 794
 795         if (irqstatus & IR_RF0L)
 796                 work_done += m_can_handle_lost_msg(dev);
 797
 798         /* handle lec errors on the bus */
 799         if ((priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) &&
 800             is_lec_err(psr))
 801                 work_done += m_can_handle_lec_err(dev, psr & LEC_UNUSED);
 802
 803         /* other unproccessed error interrupts */
 804         m_can_handle_other_err(dev, irqstatus);
 805
 806         return work_done;
 807 }
 808
 809 static int m_can_poll(struct napi_struct *napi, int quota)
 810 {
 811         struct net_device *dev = napi->dev;
 812         struct m_can_priv *priv = netdev_priv(dev);
 813         int work_done = 0;
 814         u32 irqstatus, psr;
 815
 816         irqstatus = priv->irqstatus | m_can_read(priv, M_CAN_IR);
 817         if (!irqstatus)
 818                 goto end;
 819
 820         /* Errata workaround for issue "Needless activation of MRAF irq"
 821          * During frame reception while the MCAN is in Error Passive state
 822          * and the Receive Error Counter has the value MCAN_ECR.REC = 127,
 823          * it may happen that MCAN_IR.MRAF is set although there was no
 824          * Message RAM access failure.
 825          * If MCAN_IR.MRAF is enabled, an interrupt to the Host CPU is generated
 826          * The Message RAM Access Failure interrupt routine needs to check
 827          * whether MCAN_ECR.RP = ’1’ and MCAN_ECR.REC = 127.
 828          * In this case, reset MCAN_IR.MRAF. No further action is required.
 829          */
 830         if ((priv->version <= 31) && (irqstatus & IR_MRAF) &&
 831             (m_can_read(priv, M_CAN_ECR) & ECR_RP)) {
 832                 struct can_berr_counter bec;
 833
 834                 __m_can_get_berr_counter(dev, &bec);
 835                 if (bec.rxerr == 127) {
 836                         m_can_write(priv, M_CAN_IR, IR_MRAF);
 837                         irqstatus &= ~IR_MRAF;
 838                 }
 839         }
 840
 841         psr = m_can_read(priv, M_CAN_PSR);
 842         if (irqstatus & IR_ERR_STATE)
 843                 work_done += m_can_handle_state_errors(dev, psr);
 844
 845         if (irqstatus & IR_ERR_BUS_30X)
 846                 work_done += m_can_handle_bus_errors(dev, irqstatus, psr);
 847
 848         if (irqstatus & IR_RF0N)
 849                 work_done += m_can_do_rx_poll(dev, (quota - work_done));
 850
 851         if (work_done < quota) {
 852                 napi_complete_done(napi, work_done);
 853                 m_can_enable_all_interrupts(priv);
 854         }
 855
 856 end:
 857         return work_done;
 858 }
 859
 860 static void m_can_echo_tx_event(struct net_device *dev)
 861 {
 862         u32 txe_count = 0;
 863         u32 m_can_txefs;
 864         u32 fgi = 0;
 865         int i = 0;
 866         unsigned int msg_mark;
 867
 868         struct m_can_priv *priv = netdev_priv(dev);
 869         struct net_device_stats *stats = &dev->stats;
 870
 871         /* read tx event fifo status */
 872         m_can_txefs = m_can_read(priv, M_CAN_TXEFS);
 873
 874         /* Get Tx Event fifo element count */
 875         txe_count = (m_can_txefs & TXEFS_EFFL_MASK)
 876                         >> TXEFS_EFFL_SHIFT;
 877
 878         /* Get and process all sent elements */
 879         for (i = 0; i < txe_count; i++) {
 880                 /* retrieve get index */
 881                 fgi = (m_can_read(priv, M_CAN_TXEFS) & TXEFS_EFGI_MASK)
 882                         >> TXEFS_EFGI_SHIFT;
 883
 884                 /* get message marker */
 885                 msg_mark = (m_can_txe_fifo_read(priv, fgi, 4) &
 886                             TX_EVENT_MM_MASK) >> TX_EVENT_MM_SHIFT;
 887
 888                 /* ack txe element */
 889                 m_can_write(priv, M_CAN_TXEFA, (TXEFA_EFAI_MASK &
 890                                                 (fgi << TXEFA_EFAI_SHIFT)));
 891
 892                 /* update stats */
 893                 stats->tx_bytes += can_get_echo_skb(dev, msg_mark);
 894                 stats->tx_packets++;
 895         }
 896 }
 897
 898 static irqreturn_t m_can_isr(int irq, void *dev_id)
 899 {
 900         struct net_device *dev = (struct net_device *)dev_id;
 901         struct m_can_priv *priv = netdev_priv(dev);
 902         struct net_device_stats *stats = &dev->stats;
 903         u32 ir;
 904
 905         ir = m_can_read(priv, M_CAN_IR);
 906         if (!ir)
 907                 return IRQ_NONE;
 908
 909         /* ACK all irqs */
 910         if (ir & IR_ALL_INT)
 911                 m_can_write(priv, M_CAN_IR, ir);
 912
 913         /* schedule NAPI in case of
 914          * - rx IRQ
 915          * - state change IRQ
 916          * - bus error IRQ and bus error reporting
 917          */
 918         if ((ir & IR_RF0N) || (ir & IR_ERR_ALL_30X)) {
 919                 priv->irqstatus = ir;
 920                 m_can_disable_all_interrupts(priv);
 921                 napi_schedule(&priv->napi);
 922         }
 923
 924         if (priv->version == 30) {
 925                 if (ir & IR_TC) {
 926                         /* Transmission Complete Interrupt*/
 927                         stats->tx_bytes += can_get_echo_skb(dev, 0);
 928                         stats->tx_packets++;
 929                         can_led_event(dev, CAN_LED_EVENT_TX);
 930                         netif_wake_queue(dev);
 931                 }
 932         } else  {
 933                 if (ir & IR_TEFN) {
 934                         /* New TX FIFO Element arrived */
 935                         m_can_echo_tx_event(dev);
 936                         can_led_event(dev, CAN_LED_EVENT_TX);
 937                         if (netif_queue_stopped(dev) &&
 938                             !m_can_tx_fifo_full(priv))
 939                                 netif_wake_queue(dev);
 940                 }
 941         }
 942
 943         return IRQ_HANDLED;
 944 }
 945
 946 static const struct can_bittiming_const m_can_bittiming_const_30X = {
 947         .name = KBUILD_MODNAME,
 948         .tseg1_min = 2,         /* Time segment 1 = prop_seg + phase_seg1 */
 949         .tseg1_max = 64,
 950         .tseg2_min = 1,         /* Time segment 2 = phase_seg2 */
 951         .tseg2_max = 16,
 952         .sjw_max = 16,
 953         .brp_min = 1,
 954         .brp_max = 1024,
 955         .brp_inc = 1,
 956 };
 957
 958 static const struct can_bittiming_const m_can_data_bittiming_const_30X = {
 959         .name = KBUILD_MODNAME,
 960         .tseg1_min = 2,         /* Time segment 1 = prop_seg + phase_seg1 */
 961         .tseg1_max = 16,
 962         .tseg2_min = 1,         /* Time segment 2 = phase_seg2 */
 963         .tseg2_max = 8,
 964         .sjw_max = 4,
 965         .brp_min = 1,
 966         .brp_max = 32,
 967         .brp_inc = 1,
 968 };
 969
 970 static const struct can_bittiming_const m_can_bittiming_const_31X = {
 971         .name = KBUILD_MODNAME,
 972         .tseg1_min = 2,         /* Time segment 1 = prop_seg + phase_seg1 */
 973         .tseg1_max = 256,
 974         .tseg2_min = 2,         /* Time segment 2 = phase_seg2 */
 975         .tseg2_max = 128,
 976         .sjw_max = 128,
 977         .brp_min = 1,
 978         .brp_max = 512,
 979         .brp_inc = 1,
 980 };
 981
 982 static const struct can_bittiming_const m_can_data_bittiming_const_31X = {
 983         .name = KBUILD_MODNAME,
 984         .tseg1_min = 1,         /* Time segment 1 = prop_seg + phase_seg1 */
 985         .tseg1_max = 32,
 986         .tseg2_min = 1,         /* Time segment 2 = phase_seg2 */
 987         .tseg2_max = 16,
 988         .sjw_max = 16,
 989         .brp_min = 1,
 990         .brp_max = 32,
 991         .brp_inc = 1,
 992 };
 993
 994 static int m_can_set_bittiming(struct net_device *dev)
 995 {
 996         struct m_can_priv *priv = netdev_priv(dev);
 997         const struct can_bittiming *bt = &priv->can.bittiming;
 998         const struct can_bittiming *dbt = &priv->can.data_bittiming;
 999         u16 brp, sjw, tseg1, tseg2;
1000         u32 reg_btp;
1001
1002         brp = bt->brp - 1;
1003         sjw = bt->sjw - 1;
1004         tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
1005         tseg2 = bt->phase_seg2 - 1;
1006         reg_btp = (brp << NBTP_NBRP_SHIFT) | (sjw << NBTP_NSJW_SHIFT) |
1007                 (tseg1 << NBTP_NTSEG1_SHIFT) | (tseg2 << NBTP_NTSEG2_SHIFT);
1008         m_can_write(priv, M_CAN_NBTP, reg_btp);
1009
1010         if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1011                 reg_btp = 0;
1012                 brp = dbt->brp - 1;
1013                 sjw = dbt->sjw - 1;
1014                 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
1015                 tseg2 = dbt->phase_seg2 - 1;
1016
1017                 /* TDC is only needed for bitrates beyond 2.5 MBit/s.
1018                  * This is mentioned in the "Bit Time Requirements for CAN FD"
1019                  * paper presented at the International CAN Conference 2013
1020                  */
1021                 if (dbt->bitrate > 2500000) {
1022                         u32 tdco, ssp;
1023
1024                         /* Use the same value of secondary sampling point
1025                          * as the data sampling point
1026                          */
1027                         ssp = dbt->sample_point;
1028
1029                         /* Equation based on Bosch's M_CAN User Manual's
1030                          * Transmitter Delay Compensation Section
1031                          */
1032                         tdco = (priv->can.clock.freq / 1000) *
1033                                ssp / dbt->bitrate;
1034
1035                         /* Max valid TDCO value is 127 */
1036                         if (tdco > 127) {
1037                                 netdev_warn(dev, "TDCO value of %u is beyond maximum. Using maximum possible value\n",
1038                                             tdco);
1039                                 tdco = 127;
1040                         }
1041
1042                         reg_btp |= DBTP_TDC;
1043                         m_can_write(priv, M_CAN_TDCR,
1044                                     tdco << TDCR_TDCO_SHIFT);
1045                 }
1046
1047                 reg_btp |= (brp << DBTP_DBRP_SHIFT) |
1048                            (sjw << DBTP_DSJW_SHIFT) |
1049                            (tseg1 << DBTP_DTSEG1_SHIFT) |
1050                            (tseg2 << DBTP_DTSEG2_SHIFT);
1051
1052                 m_can_write(priv, M_CAN_DBTP, reg_btp);
1053         }
1054
1055         return 0;
1056 }
1057
1058 /* Configure M_CAN chip:
1059  * - set rx buffer/fifo element size
1060  * - configure rx fifo
1061  * - accept non-matching frame into fifo 0
1062  * - configure tx buffer
1063  *              - >= v3.1.x: TX FIFO is used
1064  * - configure mode
1065  * - setup bittiming
1066  */
1067 static void m_can_chip_config(struct net_device *dev)
1068 {
1069         struct m_can_priv *priv = netdev_priv(dev);
1070         u32 cccr, test;
1071
1072         m_can_config_endisable(priv, true);
1073
1074         /* RX Buffer/FIFO Element Size 64 bytes data field */
1075         m_can_write(priv, M_CAN_RXESC, M_CAN_RXESC_64BYTES);
1076
1077         /* Accept Non-matching Frames Into FIFO 0 */
1078         m_can_write(priv, M_CAN_GFC, 0x0);
1079
1080         if (priv->version == 30) {
1081                 /* only support one Tx Buffer currently */
1082                 m_can_write(priv, M_CAN_TXBC, (1 << TXBC_NDTB_SHIFT) |
1083                                 priv->mcfg[MRAM_TXB].off);
1084         } else {
1085                 /* TX FIFO is used for newer IP Core versions */
1086                 m_can_write(priv, M_CAN_TXBC,
1087                             (priv->mcfg[MRAM_TXB].num << TXBC_TFQS_SHIFT) |
1088                             (priv->mcfg[MRAM_TXB].off));
1089         }
1090
1091         /* support 64 bytes payload */
1092         m_can_write(priv, M_CAN_TXESC, TXESC_TBDS_64BYTES);
1093
1094         /* TX Event FIFO */
1095         if (priv->version == 30) {
1096                 m_can_write(priv, M_CAN_TXEFC, (1 << TXEFC_EFS_SHIFT) |
1097                                 priv->mcfg[MRAM_TXE].off);
1098         } else {
1099                 /* Full TX Event FIFO is used */
1100                 m_can_write(priv, M_CAN_TXEFC,
1101                             ((priv->mcfg[MRAM_TXE].num << TXEFC_EFS_SHIFT)
1102                              & TXEFC_EFS_MASK) |
1103                             priv->mcfg[MRAM_TXE].off);
1104         }
1105
1106         /* rx fifo configuration, blocking mode, fifo size 1 */
1107         m_can_write(priv, M_CAN_RXF0C,
1108                     (priv->mcfg[MRAM_RXF0].num << RXFC_FS_SHIFT) |
1109                      priv->mcfg[MRAM_RXF0].off);
1110
1111         m_can_write(priv, M_CAN_RXF1C,
1112                     (priv->mcfg[MRAM_RXF1].num << RXFC_FS_SHIFT) |
1113                      priv->mcfg[MRAM_RXF1].off);
1114
1115         cccr = m_can_read(priv, M_CAN_CCCR);
1116         test = m_can_read(priv, M_CAN_TEST);
1117         test &= ~TEST_LBCK;
1118         if (priv->version == 30) {
1119         /* Version 3.0.x */
1120
1121                 cccr &= ~(CCCR_TEST | CCCR_MON |
1122                         (CCCR_CMR_MASK << CCCR_CMR_SHIFT) |
1123                         (CCCR_CME_MASK << CCCR_CME_SHIFT));
1124
1125                 if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
1126                         cccr |= CCCR_CME_CANFD_BRS << CCCR_CME_SHIFT;
1127
1128         } else {
1129         /* Version 3.1.x or 3.2.x */
1130                 cccr &= ~(CCCR_TEST | CCCR_MON | CCCR_BRSE | CCCR_FDOE |
1131                           CCCR_NISO);
1132
1133                 /* Only 3.2.x has NISO Bit implemented */
1134                 if (priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)
1135                         cccr |= CCCR_NISO;
1136
1137                 if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
1138                         cccr |= (CCCR_BRSE | CCCR_FDOE);
1139         }
1140
1141         /* Loopback Mode */
1142         if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
1143                 cccr |= CCCR_TEST | CCCR_MON;
1144                 test |= TEST_LBCK;
1145         }
1146
1147         /* Enable Monitoring (all versions) */
1148         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1149                 cccr |= CCCR_MON;
1150
1151         /* Write config */
1152         m_can_write(priv, M_CAN_CCCR, cccr);
1153         m_can_write(priv, M_CAN_TEST, test);
1154
1155         /* Enable interrupts */
1156         m_can_write(priv, M_CAN_IR, IR_ALL_INT);
1157         if (!(priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING))
1158                 if (priv->version == 30)
1159                         m_can_write(priv, M_CAN_IE, IR_ALL_INT &
1160                                     ~(IR_ERR_LEC_30X));
1161                 else
1162                         m_can_write(priv, M_CAN_IE, IR_ALL_INT &
1163                                     ~(IR_ERR_LEC_31X));
1164         else
1165                 m_can_write(priv, M_CAN_IE, IR_ALL_INT);
1166
1167         /* route all interrupts to INT0 */
1168         m_can_write(priv, M_CAN_ILS, ILS_ALL_INT0);
1169
1170         /* set bittiming params */
1171         m_can_set_bittiming(dev);
1172
1173         m_can_config_endisable(priv, false);
1174 }
1175
1176 static void m_can_start(struct net_device *dev)
1177 {
1178         struct m_can_priv *priv = netdev_priv(dev);
1179
1180         /* basic m_can configuration */
1181         m_can_chip_config(dev);
1182
1183         priv->can.state = CAN_STATE_ERROR_ACTIVE;
1184
1185         m_can_enable_all_interrupts(priv);
1186 }
1187
1188 static int m_can_set_mode(struct net_device *dev, enum can_mode mode)
1189 {
1190         switch (mode) {
1191         case CAN_MODE_START:
1192                 m_can_start(dev);
1193                 netif_wake_queue(dev);
1194                 break;
1195         default:
1196                 return -EOPNOTSUPP;
1197         }
1198
1199         return 0;
1200 }
1201
1202 /* Checks core release number of M_CAN
1203  * returns 0 if an unsupported device is detected
1204  * else it returns the release and step coded as:
1205  * return value = 10 * <release> + 1 * <step>
1206  */
1207 static int m_can_check_core_release(void __iomem *m_can_base)
1208 {
1209         u32 crel_reg;
1210         u8 rel;
1211         u8 step;
1212         int res;
1213         struct m_can_priv temp_priv = {
1214                 .base = m_can_base
1215         };
1216
1217         /* Read Core Release Version and split into version number
1218          * Example: Version 3.2.1 => rel = 3; step = 2; substep = 1;
1219          */
1220         crel_reg = m_can_read(&temp_priv, M_CAN_CREL);
1221         rel = (u8)((crel_reg & CREL_REL_MASK) >> CREL_REL_SHIFT);
1222         step = (u8)((crel_reg & CREL_STEP_MASK) >> CREL_STEP_SHIFT);
1223
1224         if (rel == 3) {
1225                 /* M_CAN v3.x.y: create return value */
1226                 res = 30 + step;
1227         } else {
1228                 /* Unsupported M_CAN version */
1229                 res = 0;
1230         }
1231
1232         return res;
1233 }
1234
1235 /* Selectable Non ISO support only in version 3.2.x
1236  * This function checks if the bit is writable.
1237  */
1238 static bool m_can_niso_supported(const struct m_can_priv *priv)
1239 {
1240         u32 cccr_reg, cccr_poll;
1241         int niso_timeout;
1242
1243         m_can_config_endisable(priv, true);
1244         cccr_reg = m_can_read(priv, M_CAN_CCCR);
1245         cccr_reg |= CCCR_NISO;
1246         m_can_write(priv, M_CAN_CCCR, cccr_reg);
1247
1248         niso_timeout = readl_poll_timeout((priv->base + M_CAN_CCCR), cccr_poll,
1249                                           (cccr_poll == cccr_reg), 0, 10);
1250
1251         /* Clear NISO */
1252         cccr_reg &= ~(CCCR_NISO);
1253         m_can_write(priv, M_CAN_CCCR, cccr_reg);
1254
1255         m_can_config_endisable(priv, false);
1256
1257         /* return false if time out (-ETIMEDOUT), else return true */
1258         return !niso_timeout;
1259 }
1260
1261 static int m_can_dev_setup(struct platform_device *pdev, struct net_device *dev,
1262                            void __iomem *addr)
1263 {
1264         struct m_can_priv *priv;
1265         int m_can_version;
1266
1267         m_can_version = m_can_check_core_release(addr);
1268         /* return if unsupported version */
1269         if (!m_can_version) {
1270                 dev_err(&pdev->dev, "Unsupported version number: %2d",
1271                         m_can_version);
1272                 return -EINVAL;
1273         }
1274
1275         priv = netdev_priv(dev);
1276         netif_napi_add(dev, &priv->napi, m_can_poll, M_CAN_NAPI_WEIGHT);
1277
1278         /* Shared properties of all M_CAN versions */
1279         priv->version = m_can_version;
1280         priv->dev = dev;
1281         priv->base = addr;
1282         priv->can.do_set_mode = m_can_set_mode;
1283         priv->can.do_get_berr_counter = m_can_get_berr_counter;
1284
1285         /* Set M_CAN supported operations */
1286         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
1287                                         CAN_CTRLMODE_LISTENONLY |
1288                                         CAN_CTRLMODE_BERR_REPORTING |
1289                                         CAN_CTRLMODE_FD;
1290
1291         /* Set properties depending on M_CAN version */
1292         switch (priv->version) {
1293         case 30:
1294                 /* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.0.x */
1295                 can_set_static_ctrlmode(dev, CAN_CTRLMODE_FD_NON_ISO);
1296                 priv->can.bittiming_const = &m_can_bittiming_const_30X;
1297                 priv->can.data_bittiming_const =
1298                                 &m_can_data_bittiming_const_30X;
1299                 break;
1300         case 31:
1301                 /* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.1.x */
1302                 can_set_static_ctrlmode(dev, CAN_CTRLMODE_FD_NON_ISO);
1303                 priv->can.bittiming_const = &m_can_bittiming_const_31X;
1304                 priv->can.data_bittiming_const =
1305                                 &m_can_data_bittiming_const_31X;
1306                 break;
1307         case 32:
1308                 priv->can.bittiming_const = &m_can_bittiming_const_31X;
1309                 priv->can.data_bittiming_const =
1310                                 &m_can_data_bittiming_const_31X;
1311                 priv->can.ctrlmode_supported |= (m_can_niso_supported(priv)
1312                                                 ? CAN_CTRLMODE_FD_NON_ISO
1313                                                 : 0);
1314                 break;
1315         default:
1316                 dev_err(&pdev->dev, "Unsupported version number: %2d",
1317                         priv->version);
1318                 return -EINVAL;
1319         }
1320
1321         return 0;
1322 }
1323
1324 static int m_can_open(struct net_device *dev)
1325 {
1326         struct m_can_priv *priv = netdev_priv(dev);
1327         int err;
1328
1329         err = m_can_clk_start(priv);
1330         if (err)
1331                 return err;
1332
1333         /* open the can device */
1334         err = open_candev(dev);
1335         if (err) {
1336                 netdev_err(dev, "failed to open can device\n");
1337                 goto exit_disable_clks;
1338         }
1339
1340         /* register interrupt handler */
1341         err = request_irq(dev->irq, m_can_isr, IRQF_SHARED, dev->name,
1342                           dev);
1343         if (err < 0) {
1344                 netdev_err(dev, "failed to request interrupt\n");
1345                 goto exit_irq_fail;
1346         }
1347
1348         /* start the m_can controller */
1349         m_can_start(dev);
1350
1351         can_led_event(dev, CAN_LED_EVENT_OPEN);
1352         napi_enable(&priv->napi);
1353         netif_start_queue(dev);
1354
1355         return 0;
1356
1357 exit_irq_fail:
1358         close_candev(dev);
1359 exit_disable_clks:
1360         m_can_clk_stop(priv);
1361         return err;
1362 }
1363
1364 static void m_can_stop(struct net_device *dev)
1365 {
1366         struct m_can_priv *priv = netdev_priv(dev);
1367
1368         /* disable all interrupts */
1369         m_can_disable_all_interrupts(priv);
1370
1371         /* set the state as STOPPED */
1372         priv->can.state = CAN_STATE_STOPPED;
1373 }
1374
1375 static int m_can_close(struct net_device *dev)
1376 {
1377         struct m_can_priv *priv = netdev_priv(dev);
1378
1379         netif_stop_queue(dev);
1380         napi_disable(&priv->napi);
1381         m_can_stop(dev);
1382         m_can_clk_stop(priv);
1383         free_irq(dev->irq, dev);
1384         close_candev(dev);
1385         can_led_event(dev, CAN_LED_EVENT_STOP);
1386
1387         return 0;
1388 }
1389
1390 static int m_can_next_echo_skb_occupied(struct net_device *dev, int putidx)
1391 {
1392         struct m_can_priv *priv = netdev_priv(dev);
1393         /*get wrap around for loopback skb index */
1394         unsigned int wrap = priv->can.echo_skb_max;
1395         int next_idx;
1396
1397         /* calculate next index */
1398         next_idx = (++putidx >= wrap ? 0 : putidx);
1399
1400         /* check if occupied */
1401         return !!priv->can.echo_skb[next_idx];
1402 }
1403
1404 static netdev_tx_t m_can_start_xmit(struct sk_buff *skb,
1405                                     struct net_device *dev)
1406 {
1407         struct m_can_priv *priv = netdev_priv(dev);
1408         struct canfd_frame *cf = (struct canfd_frame *)skb->data;
1409         u32 id, cccr, fdflags;
1410         int i;
1411         int putidx;
1412
1413         if (can_dropped_invalid_skb(dev, skb))
1414                 return NETDEV_TX_OK;
1415
1416         /* Generate ID field for TX buffer Element */
1417         /* Common to all supported M_CAN versions */
1418         if (cf->can_id & CAN_EFF_FLAG) {
1419                 id = cf->can_id & CAN_EFF_MASK;
1420                 id |= TX_BUF_XTD;
1421         } else {
1422                 id = ((cf->can_id & CAN_SFF_MASK) << 18);
1423         }
1424
1425         if (cf->can_id & CAN_RTR_FLAG)
1426                 id |= TX_BUF_RTR;
1427
1428         if (priv->version == 30) {
1429                 netif_stop_queue(dev);
1430
1431                 /* message ram configuration */
1432                 m_can_fifo_write(priv, 0, M_CAN_FIFO_ID, id);
1433                 m_can_fifo_write(priv, 0, M_CAN_FIFO_DLC,
1434                                  can_len2dlc(cf->len) << 16);
1435
1436                 for (i = 0; i < cf->len; i += 4)
1437                         m_can_fifo_write(priv, 0,
1438                                          M_CAN_FIFO_DATA(i / 4),
1439                                          *(u32 *)(cf->data + i));
1440
1441                 can_put_echo_skb(skb, dev, 0);
1442
1443                 if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1444                         cccr = m_can_read(priv, M_CAN_CCCR);
1445                         cccr &= ~(CCCR_CMR_MASK << CCCR_CMR_SHIFT);
1446                         if (can_is_canfd_skb(skb)) {
1447                                 if (cf->flags & CANFD_BRS)
1448                                         cccr |= CCCR_CMR_CANFD_BRS <<
1449                                                 CCCR_CMR_SHIFT;
1450                                 else
1451                                         cccr |= CCCR_CMR_CANFD <<
1452                                                 CCCR_CMR_SHIFT;
1453                         } else {
1454                                 cccr |= CCCR_CMR_CAN << CCCR_CMR_SHIFT;
1455                         }
1456                         m_can_write(priv, M_CAN_CCCR, cccr);
1457                 }
1458                 m_can_write(priv, M_CAN_TXBTIE, 0x1);
1459                 m_can_write(priv, M_CAN_TXBAR, 0x1);
1460                 /* End of xmit function for version 3.0.x */
1461         } else {
1462                 /* Transmit routine for version >= v3.1.x */
1463
1464                 /* Check if FIFO full */
1465                 if (m_can_tx_fifo_full(priv)) {
1466                         /* This shouldn't happen */
1467                         netif_stop_queue(dev);
1468                         netdev_warn(dev,
1469                                     "TX queue active although FIFO is full.");
1470                         return NETDEV_TX_BUSY;
1471                 }
1472
1473                 /* get put index for frame */
1474                 putidx = ((m_can_read(priv, M_CAN_TXFQS) & TXFQS_TFQPI_MASK)
1475                                   >> TXFQS_TFQPI_SHIFT);
1476                 /* Write ID Field to FIFO Element */
1477                 m_can_fifo_write(priv, putidx, M_CAN_FIFO_ID, id);
1478
1479                 /* get CAN FD configuration of frame */
1480                 fdflags = 0;
1481                 if (can_is_canfd_skb(skb)) {
1482                         fdflags |= TX_BUF_FDF;
1483                         if (cf->flags & CANFD_BRS)
1484                                 fdflags |= TX_BUF_BRS;
1485                 }
1486
1487                 /* Construct DLC Field. Also contains CAN-FD configuration
1488                  * use put index of fifo as message marker
1489                  * it is used in TX interrupt for
1490                  * sending the correct echo frame
1491                  */
1492                 m_can_fifo_write(priv, putidx, M_CAN_FIFO_DLC,
1493                                  ((putidx << TX_BUF_MM_SHIFT) &
1494                                   TX_BUF_MM_MASK) |
1495                                  (can_len2dlc(cf->len) << 16) |
1496                                  fdflags | TX_BUF_EFC);
1497
1498                 for (i = 0; i < cf->len; i += 4)
1499                         m_can_fifo_write(priv, putidx, M_CAN_FIFO_DATA(i / 4),
1500                                          *(u32 *)(cf->data + i));
1501
1502                 /* Push loopback echo.
1503                  * Will be looped back on TX interrupt based on message marker
1504                  */
1505                 can_put_echo_skb(skb, dev, putidx);
1506
1507                 /* Enable TX FIFO element to start transfer  */
1508                 m_can_write(priv, M_CAN_TXBAR, (1 << putidx));
1509
1510                 /* stop network queue if fifo full */
1511                         if (m_can_tx_fifo_full(priv) ||
1512                             m_can_next_echo_skb_occupied(dev, putidx))
1513                                 netif_stop_queue(dev);
1514         }
1515
1516         return NETDEV_TX_OK;
1517 }
1518
1519 static const struct net_device_ops m_can_netdev_ops = {
1520         .ndo_open = m_can_open,
1521         .ndo_stop = m_can_close,
1522         .ndo_start_xmit = m_can_start_xmit,
1523         .ndo_change_mtu = can_change_mtu,
1524 };
1525
1526 static int register_m_can_dev(struct net_device *dev)
1527 {
1528         dev->flags |= IFF_ECHO; /* we support local echo */
1529         dev->netdev_ops = &m_can_netdev_ops;
1530
1531         return register_candev(dev);
1532 }
1533
1534 static void m_can_init_ram(struct m_can_priv *priv)
1535 {
1536         int end, i, start;
1537
1538         /* initialize the entire Message RAM in use to avoid possible
1539          * ECC/parity checksum errors when reading an uninitialized buffer
1540          */
1541         start = priv->mcfg[MRAM_SIDF].off;
1542         end = priv->mcfg[MRAM_TXB].off +
1543                 priv->mcfg[MRAM_TXB].num * TXB_ELEMENT_SIZE;
1544         for (i = start; i < end; i += 4)
1545                 writel(0x0, priv->mram_base + i);
1546 }
1547
1548 static void m_can_of_parse_mram(struct m_can_priv *priv,
1549                                 const u32 *mram_config_vals)
1550 {
1551         priv->mcfg[MRAM_SIDF].off = mram_config_vals[0];
1552         priv->mcfg[MRAM_SIDF].num = mram_config_vals[1];
1553         priv->mcfg[MRAM_XIDF].off = priv->mcfg[MRAM_SIDF].off +
1554                         priv->mcfg[MRAM_SIDF].num * SIDF_ELEMENT_SIZE;
1555         priv->mcfg[MRAM_XIDF].num = mram_config_vals[2];
1556         priv->mcfg[MRAM_RXF0].off = priv->mcfg[MRAM_XIDF].off +
1557                         priv->mcfg[MRAM_XIDF].num * XIDF_ELEMENT_SIZE;
1558         priv->mcfg[MRAM_RXF0].num = mram_config_vals[3] &
1559                         (RXFC_FS_MASK >> RXFC_FS_SHIFT);
1560         priv->mcfg[MRAM_RXF1].off = priv->mcfg[MRAM_RXF0].off +
1561                         priv->mcfg[MRAM_RXF0].num * RXF0_ELEMENT_SIZE;
1562         priv->mcfg[MRAM_RXF1].num = mram_config_vals[4] &
1563                         (RXFC_FS_MASK >> RXFC_FS_SHIFT);
1564         priv->mcfg[MRAM_RXB].off = priv->mcfg[MRAM_RXF1].off +
1565                         priv->mcfg[MRAM_RXF1].num * RXF1_ELEMENT_SIZE;
1566         priv->mcfg[MRAM_RXB].num = mram_config_vals[5];
1567         priv->mcfg[MRAM_TXE].off = priv->mcfg[MRAM_RXB].off +
1568                         priv->mcfg[MRAM_RXB].num * RXB_ELEMENT_SIZE;
1569         priv->mcfg[MRAM_TXE].num = mram_config_vals[6];
1570         priv->mcfg[MRAM_TXB].off = priv->mcfg[MRAM_TXE].off +
1571                         priv->mcfg[MRAM_TXE].num * TXE_ELEMENT_SIZE;
1572         priv->mcfg[MRAM_TXB].num = mram_config_vals[7] &
1573                         (TXBC_NDTB_MASK >> TXBC_NDTB_SHIFT);
1574
1575         dev_dbg(priv->device,
1576                 "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",
1577                 priv->mram_base,
1578                 priv->mcfg[MRAM_SIDF].off, priv->mcfg[MRAM_SIDF].num,
1579                 priv->mcfg[MRAM_XIDF].off, priv->mcfg[MRAM_XIDF].num,
1580                 priv->mcfg[MRAM_RXF0].off, priv->mcfg[MRAM_RXF0].num,
1581                 priv->mcfg[MRAM_RXF1].off, priv->mcfg[MRAM_RXF1].num,
1582                 priv->mcfg[MRAM_RXB].off, priv->mcfg[MRAM_RXB].num,
1583                 priv->mcfg[MRAM_TXE].off, priv->mcfg[MRAM_TXE].num,
1584                 priv->mcfg[MRAM_TXB].off, priv->mcfg[MRAM_TXB].num);
1585
1586         m_can_init_ram(priv);
1587 }
1588
1589 static int m_can_plat_probe(struct platform_device *pdev)
1590 {
1591         struct net_device *dev;
1592         struct m_can_priv *priv;
1593         struct resource *res;
1594         void __iomem *addr;
1595         void __iomem *mram_addr;
1596         struct clk *hclk, *cclk;
1597         int irq, ret;
1598         struct device_node *np;
1599         u32 mram_config_vals[MRAM_CFG_LEN];
1600         u32 tx_fifo_size;
1601
1602         np = pdev->dev.of_node;
1603
1604         hclk = devm_clk_get(&pdev->dev, "hclk");
1605         cclk = devm_clk_get(&pdev->dev, "cclk");
1606
1607         if (IS_ERR(hclk) || IS_ERR(cclk)) {
1608                 dev_err(&pdev->dev, "no clock found\n");
1609                 ret = -ENODEV;
1610                 goto failed_ret;
1611         }
1612
1613         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "m_can");
1614         addr = devm_ioremap_resource(&pdev->dev, res);
1615         irq = platform_get_irq_byname(pdev, "int0");
1616
1617         if (IS_ERR(addr) || irq < 0) {
1618                 ret = -EINVAL;
1619                 goto failed_ret;
1620         }
1621
1622         /* message ram could be shared */
1623         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "message_ram");
1624         if (!res) {
1625                 ret = -ENODEV;
1626                 goto failed_ret;
1627         }
1628
1629         mram_addr = devm_ioremap(&pdev->dev, res->start, resource_size(res));
1630         if (!mram_addr) {
1631                 ret = -ENOMEM;
1632                 goto failed_ret;
1633         }
1634
1635         /* get message ram configuration */
1636         ret = of_property_read_u32_array(np, "bosch,mram-cfg",
1637                                          mram_config_vals,
1638                                          sizeof(mram_config_vals) / 4);
1639         if (ret) {
1640                 dev_err(&pdev->dev, "Could not get Message RAM configuration.");
1641                 goto failed_ret;
1642         }
1643
1644         /* Get TX FIFO size
1645          * Defines the total amount of echo buffers for loopback
1646          */
1647         tx_fifo_size = mram_config_vals[7];
1648
1649         /* allocate the m_can device */
1650         dev = alloc_candev(sizeof(*priv), tx_fifo_size);
1651         if (!dev) {
1652                 ret = -ENOMEM;
1653                 goto failed_ret;
1654         }
1655
1656         priv = netdev_priv(dev);
1657         dev->irq = irq;
1658         priv->device = &pdev->dev;
1659         priv->hclk = hclk;
1660         priv->cclk = cclk;
1661         priv->can.clock.freq = clk_get_rate(cclk);
1662         priv->mram_base = mram_addr;
1663
1664         platform_set_drvdata(pdev, dev);
1665         SET_NETDEV_DEV(dev, &pdev->dev);
1666
1667         /* Enable clocks. Necessary to read Core Release in order to determine
1668          * M_CAN version
1669          */
1670         pm_runtime_enable(&pdev->dev);
1671         ret = m_can_clk_start(priv);
1672         if (ret)
1673                 goto pm_runtime_fail;
1674
1675         ret = m_can_dev_setup(pdev, dev, addr);
1676         if (ret)
1677                 goto clk_disable;
1678
1679         ret = register_m_can_dev(dev);
1680         if (ret) {
1681                 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
1682                         KBUILD_MODNAME, ret);
1683                 goto clk_disable;
1684         }
1685
1686         m_can_of_parse_mram(priv, mram_config_vals);
1687
1688         devm_can_led_init(dev);
1689
1690         of_can_transceiver(dev);
1691
1692         dev_info(&pdev->dev, "%s device registered (irq=%d, version=%d)\n",
1693                  KBUILD_MODNAME, dev->irq, priv->version);
1694
1695         /* Probe finished
1696          * Stop clocks. They will be reactivated once the M_CAN device is opened
1697          */
1698 clk_disable:
1699         m_can_clk_stop(priv);
1700 pm_runtime_fail:
1701         if (ret) {
1702                 pm_runtime_disable(&pdev->dev);
1703                 free_candev(dev);
1704         }
1705 failed_ret:
1706         return ret;
1707 }
1708
1709 static __maybe_unused int m_can_suspend(struct device *dev)
1710 {
1711         struct net_device *ndev = dev_get_drvdata(dev);
1712         struct m_can_priv *priv = netdev_priv(ndev);
1713
1714         if (netif_running(ndev)) {
1715                 netif_stop_queue(ndev);
1716                 netif_device_detach(ndev);
1717                 m_can_stop(ndev);
1718                 m_can_clk_stop(priv);
1719         }
1720
1721         pinctrl_pm_select_sleep_state(dev);
1722
1723         priv->can.state = CAN_STATE_SLEEPING;
1724
1725         return 0;
1726 }
1727
1728 static __maybe_unused int m_can_resume(struct device *dev)
1729 {
1730         struct net_device *ndev = dev_get_drvdata(dev);
1731         struct m_can_priv *priv = netdev_priv(ndev);
1732
1733         pinctrl_pm_select_default_state(dev);
1734
1735         priv->can.state = CAN_STATE_ERROR_ACTIVE;
1736
1737         if (netif_running(ndev)) {
1738                 int ret;
1739
1740                 ret = m_can_clk_start(priv);
1741                 if (ret)
1742                         return ret;
1743
1744                 m_can_init_ram(priv);
1745                 m_can_start(ndev);
1746                 netif_device_attach(ndev);
1747                 netif_start_queue(ndev);
1748         }
1749
1750         return 0;
1751 }
1752
1753 static void unregister_m_can_dev(struct net_device *dev)
1754 {
1755         unregister_candev(dev);
1756 }
1757
1758 static int m_can_plat_remove(struct platform_device *pdev)
1759 {
1760         struct net_device *dev = platform_get_drvdata(pdev);
1761
1762         unregister_m_can_dev(dev);
1763
1764         pm_runtime_disable(&pdev->dev);
1765
1766         platform_set_drvdata(pdev, NULL);
1767
1768         free_candev(dev);
1769
1770         return 0;
1771 }
1772
1773 static int __maybe_unused m_can_runtime_suspend(struct device *dev)
1774 {
1775         struct net_device *ndev = dev_get_drvdata(dev);
1776         struct m_can_priv *priv = netdev_priv(ndev);
1777
1778         clk_disable_unprepare(priv->cclk);
1779         clk_disable_unprepare(priv->hclk);
1780
1781         return 0;
1782 }
1783
1784 static int __maybe_unused m_can_runtime_resume(struct device *dev)
1785 {
1786         struct net_device *ndev = dev_get_drvdata(dev);
1787         struct m_can_priv *priv = netdev_priv(ndev);
1788         int err;
1789
1790         err = clk_prepare_enable(priv->hclk);
1791         if (err)
1792                 return err;
1793
1794         err = clk_prepare_enable(priv->cclk);
1795         if (err)
1796                 clk_disable_unprepare(priv->hclk);
1797
1798         return err;
1799 }
1800
1801 static const struct dev_pm_ops m_can_pmops = {
1802         SET_RUNTIME_PM_OPS(m_can_runtime_suspend,
1803                            m_can_runtime_resume, NULL)
1804         SET_SYSTEM_SLEEP_PM_OPS(m_can_suspend, m_can_resume)
1805 };
1806
1807 static const struct of_device_id m_can_of_table[] = {
1808         { .compatible = "bosch,m_can", .data = NULL },
1809         { /* sentinel */ },
1810 };
1811 MODULE_DEVICE_TABLE(of, m_can_of_table);
1812
1813 static struct platform_driver m_can_plat_driver = {
1814         .driver = {
1815                 .name = KBUILD_MODNAME,
1816                 .of_match_table = m_can_of_table,
1817                 .pm     = &m_can_pmops,
1818         },
1819         .probe = m_can_plat_probe,
1820         .remove = m_can_plat_remove,
1821 };
1822
1823 module_platform_driver(m_can_plat_driver);
1824
1825 MODULE_AUTHOR("Dong Aisheng <b29396@freescale.com>");
1826 MODULE_LICENSE("GPL v2");
1827 MODULE_DESCRIPTION("CAN bus driver for Bosch M_CAN controller");