drivers/net/can/m_can/m_can.c

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