drivers/net/can/xilinx_can.c

   1 /* Xilinx CAN device driver
   2  *
   3  * Copyright (C) 2012 - 2014 Xilinx, Inc.
   4  * Copyright (C) 2009 PetaLogix. All rights reserved.
   5  *
   6  * Description:
   7  * This driver is developed for Axi CAN IP and for Zynq CANPS Controller.
   8  * This program is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/clk.h>
  20 #include <linux/errno.h>
  21 #include <linux/init.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/io.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/of.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/skbuff.h>
  30 #include <linux/string.h>
  31 #include <linux/types.h>
  32 #include <linux/can/dev.h>
  33 #include <linux/can/error.h>
  34 #include <linux/can/led.h>
  35 #include <linux/pm_runtime.h>
  36 #include <linux/of_device.h>
  37
  38 #define DRIVER_NAME     "xilinx_can"
  39
  40 /* CAN registers set */
  41 enum xcan_reg {
  42         XCAN_SRR_OFFSET         = 0x00, /* Software reset */
  43         XCAN_MSR_OFFSET         = 0x04, /* Mode select */
  44         XCAN_BRPR_OFFSET        = 0x08, /* Baud rate prescaler */
  45         XCAN_BTR_OFFSET         = 0x0C, /* Bit timing */
  46         XCAN_ECR_OFFSET         = 0x10, /* Error counter */
  47         XCAN_ESR_OFFSET         = 0x14, /* Error status */
  48         XCAN_SR_OFFSET          = 0x18, /* Status */
  49         XCAN_ISR_OFFSET         = 0x1C, /* Interrupt status */
  50         XCAN_IER_OFFSET         = 0x20, /* Interrupt enable */
  51         XCAN_ICR_OFFSET         = 0x24, /* Interrupt clear */
  52         XCAN_TXFIFO_ID_OFFSET   = 0x30,/* TX FIFO ID */
  53         XCAN_TXFIFO_DLC_OFFSET  = 0x34, /* TX FIFO DLC */
  54         XCAN_TXFIFO_DW1_OFFSET  = 0x38, /* TX FIFO Data Word 1 */
  55         XCAN_TXFIFO_DW2_OFFSET  = 0x3C, /* TX FIFO Data Word 2 */
  56         XCAN_RXFIFO_ID_OFFSET   = 0x50, /* RX FIFO ID */
  57         XCAN_RXFIFO_DLC_OFFSET  = 0x54, /* RX FIFO DLC */
  58         XCAN_RXFIFO_DW1_OFFSET  = 0x58, /* RX FIFO Data Word 1 */
  59         XCAN_RXFIFO_DW2_OFFSET  = 0x5C, /* RX FIFO Data Word 2 */
  60         XCAN_F_BRPR_OFFSET      = 0x088, /* Data Phase Buad Rate
  61                                           * Prescalar
  62                                           */
  63         XCAN_F_BTR_OFFSET       = 0x08C, /* Data Phase Bit Timing */
  64         XCAN_TRR_OFFSET         = 0x090, /* Tx Buffer Ready Request */
  65         XCAN_IETRS_OFFSET       = 0x094, /* TRR Served Interrupt
  66                                           * Enable
  67                                           */
  68         XCANFD_TXFIFO_ID_OFFSET = 0x0100, /* Tx Message Buffer Element
  69                                            * ID
  70                                            */
  71         XCANFD_TXFIFO_DLC_OFFSET = 0x0104, /* Tx Message Buffer Element
  72                                             * DLC
  73                                             */
  74         XCANFD_TXFIFO_DW_OFFSET = 0x0108, /* Tx Message Buffer Element
  75                                            * DW
  76                                            */
  77         XCANFD_RXFIFO_ID_OFFSET = 0x1100, /* Rx Message Buffer Element
  78                                            * ID
  79                                            */
  80         XCANFD_RXFIFO_DLC_OFFSET = 0x1104, /* Rx Message Buffer Element
  81                                             * DLC
  82                                             */
  83         XCANFD_RXFIFO_DW_OFFSET = 0x1108, /* Rx Message Buffer Element
  84                                            * DW
  85                                            */
  86         XCAN_AFMR_BASE_OFFSET   = 0x1A00, /* Acceptance Filter */
  87         XCAN_AFIDR_BASE_OFFSET  = 0x1A04, /* Acceptance Filter ID */
  88         XCAN_AFR_OFFSET         = 0x0E0, /* Acceptance Filter */
  89         XCAN_FSR_OFFSET         = 0x0E8, /* Receive FIFO Status */
  90         XCAN_TIMESTAMPR_OFFSET  = 0x0028, /* Time Stamp */
  91 };
  92
  93 /* CAN register bit masks - XCAN_<REG>_<BIT>_MASK */
  94 #define XCAN_SRR_CEN_MASK               0x00000002 /* CAN enable */
  95 #define XCAN_SRR_RESET_MASK             0x00000001 /* Soft Reset the CAN core */
  96 #define XCAN_MSR_LBACK_MASK             0x00000002 /* Loop back mode select */
  97 #define XCAN_MSR_SLEEP_MASK             0x00000001 /* Sleep mode select */
  98 #define XCAN_BRPR_BRP_MASK              0x000000FF /* Baud rate prescaler */
  99 #define XCAN_BTR_SJW_MASK               0x00000180 /* Synchronous jump width */
 100 #define XCAN_BTR_TS2_MASK               0x00000070 /* Time segment 2 */
 101 #define XCAN_BTR_TS1_MASK               0x0000000F /* Time segment 1 */
 102 #define XCANFD_BTR_SJW_MASK             0x000F0000 /* Sync Jump Width */
 103 #define XCANFD_BTR_TS2_MASK             0x00000F00 /* Time Segment 2 */
 104 #define XCANFD_BTR_TS1_MASK             0x0000003F /* Time Segment 1 */
 105 #define XCAN_ECR_REC_MASK               0x0000FF00 /* Receive error counter */
 106 #define XCAN_ECR_TEC_MASK               0x000000FF /* Transmit error counter */
 107 #define XCAN_ESR_ACKER_MASK             0x00000010 /* ACK error */
 108 #define XCAN_ESR_BERR_MASK              0x00000008 /* Bit error */
 109 #define XCAN_ESR_STER_MASK              0x00000004 /* Stuff error */
 110 #define XCAN_ESR_FMER_MASK              0x00000002 /* Form error */
 111 #define XCAN_ESR_CRCER_MASK             0x00000001 /* CRC error */
 112 #define XCAN_SR_TXFLL_MASK              0x00000400 /* TX FIFO is full */
 113 #define XCAN_SR_ESTAT_MASK              0x00000180 /* Error status */
 114 #define XCAN_SR_ERRWRN_MASK             0x00000040 /* Error warning */
 115 #define XCAN_SR_NORMAL_MASK             0x00000008 /* Normal mode */
 116 #define XCAN_SR_LBACK_MASK              0x00000002 /* Loop back mode */
 117 #define XCAN_SR_CONFIG_MASK             0x00000001 /* Configuration mode */
 118 #define XCAN_IXR_TXFEMP_MASK            0x00004000 /* TX FIFO Empty */
 119 #define XCAN_IXR_WKUP_MASK              0x00000800 /* Wake up interrupt */
 120 #define XCAN_IXR_SLP_MASK               0x00000400 /* Sleep interrupt */
 121 #define XCAN_IXR_BSOFF_MASK             0x00000200 /* Bus off interrupt */
 122 #define XCAN_IXR_ERROR_MASK             0x00000100 /* Error interrupt */
 123 #define XCAN_IXR_RXNEMP_MASK            0x00000080 /* RX FIFO NotEmpty intr */
 124 #define XCAN_IXR_RXOFLW_MASK            0x00000040 /* RX FIFO Overflow intr */
 125 #define XCAN_IXR_RXOK_MASK              0x00000010 /* Message received intr */
 126 #define XCAN_IXR_TXFLL_MASK             0x00000004 /* Tx FIFO Full intr */
 127 #define XCAN_IXR_TXOK_MASK              0x00000002 /* TX successful intr */
 128 #define XCAN_IXR_ARBLST_MASK            0x00000001 /* Arbitration lost intr */
 129 #define XCAN_IDR_ID1_MASK               0xFFE00000 /* Standard msg identifier */
 130 #define XCAN_IDR_SRR_MASK               0x00100000 /* Substitute remote TXreq */
 131 #define XCAN_IDR_IDE_MASK               0x00080000 /* Identifier extension */
 132 #define XCAN_IDR_ID2_MASK               0x0007FFFE /* Extended message ident */
 133 #define XCAN_IDR_RTR_MASK               0x00000001 /* Remote TX request */
 134 #define XCAN_DLCR_DLC_MASK              0xF0000000 /* Data length code */
 135 #define XCAN_MSR_BRSD_MASK              0x00000008 /* Bit Rate Switch Select */
 136 #define XCAN_MSR_SNOOP_MASK             0x00000004 /* Snoop Mode Select */
 137 #define XCAN_MSR_DPEE_MASK              0x00000020 /* Protocol Exception
 138                                                     * Event
 139                                                     */
 140 #define XCAN_MSR_SBR_MASK               0x00000040 /* Start Bus-Off Recovery */
 141 #define XCAN_MSR_ABR_MASK               0x00000080 /* Auto Bus-Off Recovery */
 142 #define XCAN_MSR_CONFIG_MASK            0x000000F8 /* Configuration Mode */
 143 #define XCAN_F_BRPR_TDCMASK             0x00001F00 /* TDC Value */
 144 #define XCAN_F_BTR_SJW_MASK             0x00070000 /* Sync Jump Width */
 145 #define XCAN_F_BTR_TS2_MASK             0x00000700 /* Time Segment 2 */
 146 #define XCAN_F_BTR_TS1_MASK             0x0000000F /* Time Segment 1 */
 147 #define XCAN_ESR_F_BERR_MASK            0x00000800 /* F_Bit Error */
 148 #define XCAN_ESR_F_STER_MASK            0x00000400 /* F_Stuff Error */
 149 #define XCAN_ESR_F_FMER_MASK            0x00000200 /* F_Form Error */
 150 #define XCAN_ESR_F_CRCER_MASK           0x00000100 /* F_CRC Error */
 151 #define XCAN_SR_SNOOP_MASK              0x00001000 /* Snoop Mode */
 152 #define XCAN_SR_BBSY_MASK               0x00000020 /* Bus Busy */
 153 #define XCAN_SR_BIDLE_MASK              0x00000010 /* Bus Idle */
 154 #define XCAN_SR_SLEEP_MASK              0x00000004 /* Sleep Mode */
 155 #define XCAN_SR_PEE_CONFIG_MASK         0x00000200 /* Protocol Exception
 156                                                     * Mode Indicator
 157                                                     */
 158 #define XCAN_SR_BSFR_CONFIG_MASK        0x00000400 /* Bus-Off recovery
 159                                                     * Mode Indicator
 160                                                     */
 161 #define XCAN_SR_NISO_MASK       0x00000800 /* Non-ISO Core */
 162 #define XCAN_FSR_FL_MASK        0x00003F00 /* Fill Level */
 163 #define XCAN_FSR_RI_MASK        0x0000001F /* Read Index */
 164 #define XCAN_FSR_IRI_MASK       0x00000080 /* Increment Read Index */
 165 #define XCAN_IXR_RXMNF_MASK     0x00020000 /* Rx Match Not Finished Intr */
 166 #define XCAN_IXR_TXRRS_MASK     0x00002000 /* Tx Buffer Ready Request Served
 167                                             * Intr
 168                                             */
 169 #define XCAN_IXR_PEE_MASK       0x00000004 /* Protocol Exception Intr */
 170 #define XCAN_IXR_BSRD_MASK      0x00000008 /* Bus-Off recovery done Intr */
 171 #define XCAN_AFR_ENABLE_ALL     0xFFFFFFFF /* All filter Enable */
 172 #define XCAN_DLCR_EDL_MASK      0x08000000 /* EDL Mask in DLC */
 173 #define XCAN_DLCR_BRS_MASK      0x04000000 /* BRS Mask in DLC */
 174 #define XCAN_DLCR_DLC_SHIFT     28 /* BRS Mask in DLC */
 175 #define XCAN_DLCR_EDL_SHIFT     27 /* EDL Mask in DLC */
 176 #define XCAN_DLCR_BRS_SHIFT     26
 177
 178 #define XCAN_INTR_ALL   (XCAN_IXR_TXOK_MASK | XCAN_IXR_BSOFF_MASK |\
 179                          XCAN_IXR_WKUP_MASK | XCAN_IXR_SLP_MASK | \
 180                          XCAN_IXR_ERROR_MASK | XCAN_IXR_RXOFLW_MASK | \
 181                          XCAN_IXR_ARBLST_MASK)
 182
 183 /* CAN register bit shift - XCAN_<REG>_<BIT>_SHIFT */
 184 #define XCAN_BTR_SJW_SHIFT      7 /* Synchronous jump width */
 185 #define XCAN_BTR_TS2_SHIFT      4 /* Time segment 2 */
 186 #define XCANFD_BTR_SJW_SHIFT    16 /* Sync Jump Width Shift */
 187 #define XCANFD_BTR_TS2_SHIFT    8 /* Time Segment 2 Shift */
 188 #define XCAN_SR_ESTAT_SHIFT     7 /* Error Status Shift */
 189 #define XCAN_RXLRM_BI_SHIFT     18 /* Rx Buffer Index Shift Value */
 190 #define XCAN_CSB_SHIFT          16 /* Core Status Bit Shift Value */
 191 #define XCAN_IDR_SRR_SHIFT      20 /* Soft Reset Shift */
 192 #define XCAN_IDR_IDE_SHIFT      19 /* Identifier Extension Shift */
 193 #define XCAN_IDR_ID1_SHIFT      21 /* Standard Messg Identifier */
 194 #define XCAN_IDR_ID2_SHIFT      1 /* Extended Message Identifier */
 195 #define XCAN_DLCR_DLC_SHIFT     28 /* Data length code */
 196 #define XCAN_ESR_REC_SHIFT      8 /* Rx Error Count */
 197
 198 /* CAN frame length constants */
 199 #define XCAN_FRAME_MAX_DATA_LEN         8
 200 #define XCAN_TIMEOUT                    (1 * HZ)
 201 #define XCANFD_MAX_FRAME_LEN            72
 202 #define XCANFD_FRAME_MAX_DATA_LEN       64
 203 #define XCANFD_DW_BYTES                 4
 204 #define XCANFD_CTRLREG_WIDTH            4
 205
 206 /* Quirks */
 207 #define CANFD_SUPPORT   BIT(0)
 208
 209 /* CANFD Tx and Rx Ram offsets */
 210 #define XCANFD_TXDW_OFFSET(n)           (XCANFD_TXFIFO_DW_OFFSET + ((n) * \
 211                                         XCANFD_MAX_FRAME_LEN))
 212 #define XCANFD_TXID_OFFSET(n)           (XCANFD_TXFIFO_ID_OFFSET + ((n) * \
 213                                         XCANFD_MAX_FRAME_LEN))
 214 #define XCANFD_TXDLC_OFFSET(n)          (XCANFD_TXFIFO_DLC_OFFSET + ((n) *\
 215                                         XCANFD_MAX_FRAME_LEN))
 216 #define XCANFD_RXDLC_OFFSET(readindex)  (XCANFD_RXFIFO_DLC_OFFSET + \
 217                                         ((readindex) * XCANFD_MAX_FRAME_LEN))
 218 #define XCANFD_RXID_OFFSET(readindex)   (XCANFD_RXFIFO_ID_OFFSET + \
 219                                         ((readindex) * XCANFD_MAX_FRAME_LEN))
 220 #define XCANFD_RXDW_OFFSET(readindex)   (XCANFD_RXFIFO_DW_OFFSET + \
 221                                         ((readindex) * XCANFD_MAX_FRAME_LEN))
 222
 223 /**
 224  * struct xcan_priv - This definition define CAN driver instance
 225  * @can:                        CAN private data structure.
 226  * @tx_head:                    Tx CAN packets ready to send on the queue
 227  * @tx_tail:                    Tx CAN packets successfully sended on the queue
 228  * @tx_max:                     Maximum number packets the driver can send
 229  * @napi:                       NAPI structure
 230  * @read_reg:                   For reading data from CAN registers
 231  * @write_reg:                  For writing data to CAN registers
 232  * @dev:                        Network device data structure
 233  * @reg_base:                   Ioremapped address to registers
 234  * @irq_flags:                  For request_irq()
 235  * @bus_clk:                    Pointer to struct clk
 236  * @can_clk:                    Pointer to struct clk
 237  * @quirks:                     Needed for different IP cores
 238  */
 239 struct xcan_priv {
 240         struct can_priv can;
 241         unsigned int tx_head;
 242         unsigned int tx_tail;
 243         unsigned int tx_max;
 244         struct napi_struct napi;
 245         u32 (*read_reg)(const struct xcan_priv *priv, enum xcan_reg reg);
 246         void (*write_reg)(const struct xcan_priv *priv, enum xcan_reg reg,
 247                           u32 val);
 248         struct device *dev;
 249         void __iomem *reg_base;
 250         unsigned long irq_flags;
 251         struct clk *bus_clk;
 252         struct clk *can_clk;
 253         u32 quirks;
 254 };
 255
 256 struct xcan_platform_data {
 257         u32 quirks;
 258 };
 259
 260 /* CAN Bittiming constants as per Xilinx CAN specs */
 261 static struct can_bittiming_const xcan_bittiming_const = {
 262         .name = DRIVER_NAME,
 263         .tseg1_min = 1,
 264         .tseg1_max = 16,
 265         .tseg2_min = 1,
 266         .tseg2_max = 8,
 267         .sjw_max = 4,
 268         .brp_min = 1,
 269         .brp_max = 256,
 270         .brp_inc = 1,
 271 };
 272
 273 /* CAN Data Bittiming constants as per Xilinx CAN specs */
 274 static struct can_bittiming_const xcan_data_bittiming_const = {
 275         .name = DRIVER_NAME,
 276         .tseg1_min = 1,
 277         .tseg1_max = 16,
 278         .tseg2_min = 1,
 279         .tseg2_max = 8,
 280         .sjw_max = 8,
 281         .brp_min = 1,
 282         .brp_max = 256,
 283         .brp_inc = 1,
 284 };
 285
 286 /**
 287  * xcan_write_reg_le - Write a value to the device register little endian
 288  * @priv:       Driver private data structure
 289  * @reg:        Register offset
 290  * @val:        Value to write at the Register offset
 291  *
 292  * Write data to the paricular CAN register
 293  */
 294 static void xcan_write_reg_le(const struct xcan_priv *priv, enum xcan_reg reg,
 295                               u32 val)
 296 {
 297         iowrite32(val, priv->reg_base + reg);
 298 }
 299
 300 /**
 301  * xcan_read_reg_le - Read a value from the device register little endian
 302  * @priv:       Driver private data structure
 303  * @reg:        Register offset
 304  *
 305  * Read data from the particular CAN register
 306  * Return: value read from the CAN register
 307  */
 308 static u32 xcan_read_reg_le(const struct xcan_priv *priv, enum xcan_reg reg)
 309 {
 310         return ioread32(priv->reg_base + reg);
 311 }
 312
 313 /**
 314  * xcan_write_reg_be - Write a value to the device register big endian
 315  * @priv:       Driver private data structure
 316  * @reg:        Register offset
 317  * @val:        Value to write at the Register offset
 318  *
 319  * Write data to the paricular CAN register
 320  */
 321 static void xcan_write_reg_be(const struct xcan_priv *priv, enum xcan_reg reg,
 322                               u32 val)
 323 {
 324         iowrite32be(val, priv->reg_base + reg);
 325 }
 326
 327 /**
 328  * xcan_read_reg_be - Read a value from the device register big endian
 329  * @priv:       Driver private data structure
 330  * @reg:        Register offset
 331  *
 332  * Read data from the particular CAN register
 333  * Return: value read from the CAN register
 334  */
 335 static u32 xcan_read_reg_be(const struct xcan_priv *priv, enum xcan_reg reg)
 336 {
 337         return ioread32be(priv->reg_base + reg);
 338 }
 339
 340 /**
 341  * set_reset_mode - Resets the CAN device mode
 342  * @ndev:       Pointer to net_device structure
 343  *
 344  * This is the driver reset mode routine.The driver
 345  * enters into configuration mode.
 346  *
 347  * Return: 0 on success and failure value on error
 348  */
 349 static int set_reset_mode(struct net_device *ndev)
 350 {
 351         struct xcan_priv *priv = netdev_priv(ndev);
 352         unsigned long timeout;
 353
 354         priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK);
 355
 356         timeout = jiffies + XCAN_TIMEOUT;
 357         while (!(priv->read_reg(priv, XCAN_SR_OFFSET) & XCAN_SR_CONFIG_MASK)) {
 358                 if (time_after(jiffies, timeout)) {
 359                         netdev_warn(ndev, "timed out for config mode\n");
 360                         return -ETIMEDOUT;
 361                 }
 362                 usleep_range(500, 10000);
 363         }
 364
 365         return 0;
 366 }
 367
 368 /**
 369  * xcan_set_bittiming - CAN set bit timing routine
 370  * @ndev:       Pointer to net_device structure
 371  *
 372  * This is the driver set bittiming  routine.
 373  * Return: 0 on success and failure value on error
 374  */
 375 static int xcan_set_bittiming(struct net_device *ndev)
 376 {
 377         struct xcan_priv *priv = netdev_priv(ndev);
 378         struct can_bittiming *bt = &priv->can.bittiming;
 379         struct can_bittiming *dbt = &priv->can.data_bittiming;
 380         u32 btr0, btr1;
 381         u32 is_config_mode;
 382
 383         /* Check whether Xilinx CAN is in configuration mode.
 384          * It cannot set bit timing if Xilinx CAN is not in configuration mode.
 385          */
 386         is_config_mode = priv->read_reg(priv, XCAN_SR_OFFSET) &
 387                                 XCAN_SR_CONFIG_MASK;
 388         if (!is_config_mode) {
 389                 netdev_alert(ndev,
 390                              "BUG! Cannot set bittiming - CAN is not in config mode\n");
 391                 return -EPERM;
 392         }
 393
 394         /* Setting Baud Rate prescalar value in BRPR Register */
 395         btr0 = (bt->brp - 1);
 396
 397         /* Setting Time Segment 1 in BTR Register */
 398         btr1 = (bt->prop_seg + bt->phase_seg1 - 1);
 399
 400         /* Setting Time Segment 2 in BTR Register */
 401         btr1 |= (bt->phase_seg2 - 1) << ((priv->quirks & CANFD_SUPPORT) ?
 402                         XCANFD_BTR_TS2_SHIFT : XCAN_BTR_TS2_SHIFT);
 403
 404         /* Setting Synchronous jump width in BTR Register */
 405         btr1 |= (bt->sjw - 1) << ((priv->quirks & CANFD_SUPPORT) ?
 406                         XCANFD_BTR_SJW_SHIFT : XCAN_BTR_SJW_SHIFT);
 407
 408         priv->write_reg(priv, XCAN_BRPR_OFFSET, btr0);
 409         priv->write_reg(priv, XCAN_BTR_OFFSET, btr1);
 410
 411         netdev_dbg(ndev, "BRPR=0x%08x, BTR=0x%08x\n",
 412                    priv->read_reg(priv, XCAN_BRPR_OFFSET),
 413                    priv->read_reg(priv, XCAN_BTR_OFFSET));
 414
 415         if (priv->quirks & CANFD_SUPPORT) {
 416                 /* Setting Baud Rate prescalar value in F_BRPR Register */
 417                 btr0 = dbt->brp - 1;
 418
 419                 /* Setting Time Segment 1 in BTR Register */
 420                 btr1 = dbt->prop_seg + bt->phase_seg1 - 1;
 421
 422                 /* Setting Time Segment 2 in BTR Register */
 423                 btr1 |= (dbt->phase_seg2 - 1) << XCAN_BTR_TS2_SHIFT;
 424
 425                 /* Setting Synchronous jump width in BTR Register */
 426                 btr1 |= (dbt->sjw - 1) << XCAN_BTR_SJW_SHIFT;
 427
 428                 priv->write_reg(priv, XCAN_F_BRPR_OFFSET, btr0);
 429                 priv->write_reg(priv, XCAN_F_BTR_OFFSET, btr1);
 430         }
 431         netdev_dbg(ndev, "F_BRPR=0x%08x, F_BTR=0x%08x\n",
 432                    priv->read_reg(priv, XCAN_F_BRPR_OFFSET),
 433                    priv->read_reg(priv, XCAN_F_BTR_OFFSET));
 434
 435         return 0;
 436 }
 437
 438 /**
 439  * xcan_chip_start - This the drivers start routine
 440  * @ndev:       Pointer to net_device structure
 441  *
 442  * This is the drivers start routine.
 443  * Based on the State of the CAN device it puts
 444  * the CAN device into a proper mode.
 445  *
 446  * Return: 0 on success and failure value on error
 447  */
 448 static int xcan_chip_start(struct net_device *ndev)
 449 {
 450         struct xcan_priv *priv = netdev_priv(ndev);
 451         u32 reg_msr, reg_sr_mask, intr_all = 0;
 452         int err;
 453         unsigned long timeout;
 454
 455         /* Check if it is in reset mode */
 456         err = set_reset_mode(ndev);
 457         if (err < 0)
 458                 return err;
 459
 460         err = xcan_set_bittiming(ndev);
 461         if (err < 0)
 462                 return err;
 463
 464         /* Enable interrupts */
 465         if (priv->quirks & CANFD_SUPPORT) {
 466                 intr_all = XCAN_INTR_ALL | XCAN_IXR_PEE_MASK |
 467                                 XCAN_IXR_BSRD_MASK | XCAN_IXR_RXMNF_MASK |
 468                                 XCAN_IXR_TXRRS_MASK | XCAN_IXR_RXOK_MASK;
 469         } else {
 470                 intr_all = XCAN_INTR_ALL | XCAN_IXR_RXNEMP_MASK;
 471         }
 472
 473         priv->write_reg(priv, XCAN_IER_OFFSET, intr_all);
 474
 475         /* Check whether it is loopback mode or normal mode  */
 476         if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
 477                 reg_msr = XCAN_MSR_LBACK_MASK;
 478                 reg_sr_mask = XCAN_SR_LBACK_MASK;
 479         } else {
 480                 reg_msr = 0x0;
 481                 reg_sr_mask = XCAN_SR_NORMAL_MASK;
 482         }
 483
 484         if (priv->quirks & CANFD_SUPPORT) {
 485                 /* As per Xilinx canfd spec, default filter enabling is
 486                  * required
 487                  */
 488                 priv->write_reg(priv, XCAN_AFR_OFFSET, XCAN_AFR_ENABLE_ALL);
 489         }
 490         priv->write_reg(priv, XCAN_MSR_OFFSET, reg_msr);
 491         priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_CEN_MASK);
 492
 493         timeout = jiffies + XCAN_TIMEOUT;
 494         while (!(priv->read_reg(priv, XCAN_SR_OFFSET) & reg_sr_mask)) {
 495                 if (time_after(jiffies, timeout)) {
 496                         netdev_warn(ndev,
 497                                     "timed out for correct mode\n");
 498                         return -ETIMEDOUT;
 499                 }
 500         }
 501         netdev_dbg(ndev, "status:#x%08x\n",
 502                    priv->read_reg(priv, XCAN_SR_OFFSET));
 503
 504         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 505         priv->tx_head = 0;
 506         priv->tx_tail = 0;
 507
 508         return 0;
 509 }
 510
 511 /**
 512  * xcan_do_set_mode - This sets the mode of the driver
 513  * @ndev:       Pointer to net_device structure
 514  * @mode:       Tells the mode of the driver
 515  *
 516  * This check the drivers state and calls the
 517  * the corresponding modes to set.
 518  *
 519  * Return: 0 on success and failure value on error
 520  */
 521 static int xcan_do_set_mode(struct net_device *ndev, enum can_mode mode)
 522 {
 523         int ret;
 524
 525         switch (mode) {
 526         case CAN_MODE_START:
 527                 ret = xcan_chip_start(ndev);
 528                 if (ret < 0) {
 529                         netdev_err(ndev, "xcan_chip_start failed!\n");
 530                         return ret;
 531                 }
 532                 netif_wake_queue(ndev);
 533                 break;
 534         default:
 535                 ret = -EOPNOTSUPP;
 536                 break;
 537         }
 538
 539         return ret;
 540 }
 541
 542 /**
 543  * xcan_get_freebuffer - Checks free buffer in the configured buffers
 544  * @priv:       Driver private data structure
 545  *
 546  * While sending data, need to find free buffer from the tx
 547  * buffers avialable and then write data to that buffer.
 548  *
 549  * Return: Free Buffer on success and -1 if no buffer available
 550  */
 551 static int xcan_get_freebuffer(struct xcan_priv *priv)
 552 {
 553         u32 bufindex = 0, trrregval = 0;
 554
 555         trrregval = priv->read_reg(priv, XCAN_TRR_OFFSET);
 556         for (bufindex = 0; bufindex < priv->tx_max; bufindex++) {
 557                 if (trrregval & (1 << bufindex))
 558                         continue;
 559                 return bufindex;
 560         }
 561         return -1;
 562 }
 563
 564 /**
 565  * xcan_start_xmit - Starts the transmission
 566  * @skb:        sk_buff pointer that contains data to be Txed
 567  * @ndev:       Pointer to net_device structure
 568  *
 569  * This function is invoked from upper layers to initiate transmission. This
 570  * function uses the next available free txbuff and populates their fields to
 571  * start the transmission.
 572  *
 573  * Return: 0 on success and failure value on error
 574  */
 575 static int xcan_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 576 {
 577         struct xcan_priv *priv = netdev_priv(ndev);
 578         struct net_device_stats *stats = &ndev->stats;
 579         struct canfd_frame *cf = (struct canfd_frame *)skb->data;
 580         u32 id, dlc, data[2] = {0, 0};
 581         u32 buffnr, ramoff, dwindex = 0, i, trrval;
 582
 583         if (can_dropped_invalid_skb(ndev, skb))
 584                 return NETDEV_TX_OK;
 585
 586         if (!(priv->quirks & CANFD_SUPPORT)) {
 587                 /* Check if the TX buffer is full */
 588                 if (unlikely(priv->read_reg(priv, XCAN_SR_OFFSET) &
 589                                 XCAN_SR_TXFLL_MASK)) {
 590                         netif_stop_queue(ndev);
 591                         netdev_err(ndev, "BUG!, TX FIFO full when queue awake!\n");
 592                         return NETDEV_TX_BUSY;
 593                 }
 594         }
 595
 596         /* Watch carefully on the bit sequence */
 597         if (cf->can_id & CAN_EFF_FLAG) {
 598                 /* Extended CAN ID format */
 599                 id = ((cf->can_id & CAN_EFF_MASK) << XCAN_IDR_ID2_SHIFT) &
 600                         XCAN_IDR_ID2_MASK;
 601                 id |= (((cf->can_id & CAN_EFF_MASK) >>
 602                         (CAN_EFF_ID_BITS - CAN_SFF_ID_BITS)) <<
 603                         XCAN_IDR_ID1_SHIFT) & XCAN_IDR_ID1_MASK;
 604
 605                 /* The substibute remote TX request bit should be "1"
 606                  * for extended frames as in the Xilinx CAN datasheet
 607                  */
 608                 id |= XCAN_IDR_IDE_MASK | XCAN_IDR_SRR_MASK;
 609
 610                 if (cf->can_id & CAN_RTR_FLAG)
 611                         /* Extended frames remote TX request */
 612                         id |= XCAN_IDR_RTR_MASK;
 613         } else {
 614                 /* Standard CAN ID format */
 615                 id = ((cf->can_id & CAN_SFF_MASK) << XCAN_IDR_ID1_SHIFT) &
 616                         XCAN_IDR_ID1_MASK;
 617
 618                 if (cf->can_id & CAN_RTR_FLAG)
 619                         /* Standard frames remote TX request */
 620                         id |= XCAN_IDR_SRR_MASK;
 621         }
 622
 623         dlc = can_len2dlc(cf->len) << XCAN_DLCR_DLC_SHIFT;
 624         if (priv->quirks & CANFD_SUPPORT) {
 625                 if (can_is_canfd_skb(skb)) {
 626                         if (cf->flags & CANFD_BRS)
 627                                 dlc |= XCAN_DLCR_BRS_MASK;
 628                         dlc |= XCAN_DLCR_EDL_MASK;
 629                 }
 630
 631                 can_put_echo_skb(skb, ndev, priv->tx_head % priv->tx_max);
 632                 priv->tx_head++;
 633                 buffnr = xcan_get_freebuffer(priv);
 634                 if (buffnr == -1)
 635                         netif_stop_queue(ndev);
 636
 637                 priv->write_reg(priv, XCANFD_TXID_OFFSET(buffnr), id);
 638                 priv->write_reg(priv, XCANFD_TXDLC_OFFSET(buffnr), dlc);
 639
 640                 for (i = 0; i < cf->len; i += 4) {
 641                         ramoff = XCANFD_TXDW_OFFSET(buffnr) + (dwindex *
 642                                         XCANFD_DW_BYTES);
 643                         priv->write_reg(priv, ramoff,
 644                                         be32_to_cpup((__be32 *)(cf->data + i)));
 645                         dwindex++;
 646                 }
 647
 648                 trrval = priv->read_reg(priv, XCAN_TRR_OFFSET);
 649                 trrval |= 1 << buffnr;
 650                 priv->write_reg(priv, XCAN_TRR_OFFSET, trrval);
 651                 stats->tx_bytes += cf->len;
 652                 if (buffnr == -1)
 653                         netif_stop_queue(ndev);
 654         } else {
 655                 if (cf->len > 0)
 656                         data[0] = be32_to_cpup((__be32 *)(cf->data + 0));
 657                 if (cf->len > 4)
 658                         data[1] = be32_to_cpup((__be32 *)(cf->data + 4));
 659
 660                 can_put_echo_skb(skb, ndev, priv->tx_head % priv->tx_max);
 661                 priv->tx_head++;
 662
 663                 /* Write the Frame to Xilinx CAN TX FIFO */
 664                 priv->write_reg(priv, XCAN_TXFIFO_ID_OFFSET, id);
 665                 /* If the CAN frame is RTR frame this write triggers
 666                  * tranmission
 667                  */
 668                 priv->write_reg(priv, XCAN_TXFIFO_DLC_OFFSET, dlc);
 669                 if (!(cf->can_id & CAN_RTR_FLAG)) {
 670                         priv->write_reg(priv, XCAN_TXFIFO_DW1_OFFSET, data[0]);
 671                         /* If the CAN frame is Standard/Extended frame this
 672                          * write triggers tranmission
 673                          */
 674                         priv->write_reg(priv, XCAN_TXFIFO_DW2_OFFSET, data[1]);
 675                         stats->tx_bytes += cf->len;
 676                 }
 677         }
 678         /* Check if the TX buffer is full */
 679         if ((priv->tx_head - priv->tx_tail) == priv->tx_max)
 680                 netif_stop_queue(ndev);
 681
 682         return NETDEV_TX_OK;
 683 }
 684
 685 /**
 686  * xcan_rx -  Is called from CAN isr to complete the received
 687  *              frame  processing
 688  * @ndev:       Pointer to net_device structure
 689  *
 690  * This function is invoked from the CAN isr(poll) to process the Rx frames. It
 691  * does minimal processing and invokes "netif_receive_skb" to complete further
 692  * processing.
 693  * Return: 1 on success and 0 on failure.
 694  */
 695 static int xcan_rx(struct net_device *ndev)
 696 {
 697         struct xcan_priv *priv = netdev_priv(ndev);
 698         struct net_device_stats *stats = &ndev->stats;
 699         struct can_frame *cf;
 700         struct sk_buff *skb;
 701         u32 id_xcan, dlc, data[2] = {0, 0};
 702
 703         /* Read a frame from Xilinx zynq CANPS */
 704         id_xcan = priv->read_reg(priv, XCAN_RXFIFO_ID_OFFSET);
 705         dlc = priv->read_reg(priv, XCAN_RXFIFO_DLC_OFFSET) >>
 706                                 XCAN_DLCR_DLC_SHIFT;
 707         skb = alloc_can_skb(ndev, &cf);
 708         if (unlikely(!skb)) {
 709                 stats->rx_dropped++;
 710                 return 0;
 711         }
 712
 713         /* Change Xilinx CAN data length format to socketCAN data format */
 714         cf->can_dlc = get_can_dlc(dlc);
 715
 716         /* Change Xilinx CAN ID format to socketCAN ID format */
 717         if (id_xcan & XCAN_IDR_IDE_MASK) {
 718                 /* The received frame is an Extended format frame */
 719                 cf->can_id = (id_xcan & XCAN_IDR_ID1_MASK) >> 3;
 720                 cf->can_id |= (id_xcan & XCAN_IDR_ID2_MASK) >>
 721                                 XCAN_IDR_ID2_SHIFT;
 722                 cf->can_id |= CAN_EFF_FLAG;
 723                 if (id_xcan & XCAN_IDR_RTR_MASK)
 724                         cf->can_id |= CAN_RTR_FLAG;
 725         } else {
 726                 /* The received frame is a standard format frame */
 727                 cf->can_id = (id_xcan & XCAN_IDR_ID1_MASK) >>
 728                                 XCAN_IDR_ID1_SHIFT;
 729                 if (id_xcan & XCAN_IDR_SRR_MASK)
 730                         cf->can_id |= CAN_RTR_FLAG;
 731         }
 732
 733         /* DW1/DW2 must always be read to remove message from RXFIFO */
 734         data[0] = priv->read_reg(priv, XCAN_RXFIFO_DW1_OFFSET);
 735         data[1] = priv->read_reg(priv, XCAN_RXFIFO_DW2_OFFSET);
 736
 737         if (!(cf->can_id & CAN_RTR_FLAG)) {
 738                 /* Change Xilinx CAN data format to socketCAN data format */
 739                 if (cf->can_dlc > 0)
 740                         *(__be32 *)(cf->data) = cpu_to_be32(data[0]);
 741                 if (cf->can_dlc > 4)
 742                         *(__be32 *)(cf->data + 4) = cpu_to_be32(data[1]);
 743         }
 744
 745         stats->rx_bytes += cf->can_dlc;
 746         stats->rx_packets++;
 747         netif_receive_skb(skb);
 748
 749         return 1;
 750 }
 751
 752 /**
 753  * xcanfd_rx -  Is called from CAN isr to complete the received
 754  *              frame  processing
 755  * @ndev:       Pointer to net_device structure
 756  *
 757  * This function is invoked from the CAN isr(poll) to process the Rx frames. It
 758  * does minimal processing and invokes "netif_receive_skb" to complete further
 759  * processing.
 760  * Return: 1 on success and 0 on failure.
 761  */
 762 static int xcanfd_rx(struct net_device *ndev)
 763 {
 764         struct xcan_priv *priv = netdev_priv(ndev);
 765         struct net_device_stats *stats = &ndev->stats;
 766         struct canfd_frame *cf;
 767         struct sk_buff *skb;
 768         u32 id_xcan, dlc, data[2] = {0, 0}, dwindex = 0, i, fsr, readindex;
 769
 770         fsr = priv->read_reg(priv, XCAN_FSR_OFFSET);
 771         if (fsr & XCAN_FSR_FL_MASK) {
 772                 readindex = fsr & XCAN_FSR_RI_MASK;
 773                 id_xcan = priv->read_reg(priv, XCANFD_RXID_OFFSET(readindex));
 774                 dlc = priv->read_reg(priv, XCANFD_RXDLC_OFFSET(readindex));
 775                 if (dlc & XCAN_DLCR_EDL_MASK)
 776                         skb = alloc_canfd_skb(ndev, &cf);
 777                 else
 778                         skb = alloc_can_skb(ndev, (struct can_frame **)&cf);
 779
 780                 if (unlikely(!skb)) {
 781                         stats->rx_dropped++;
 782                         return 0;
 783                 }
 784
 785                 /* Change Xilinx CANFD data length format to socketCAN data
 786                  * format
 787                  */
 788                 if (dlc & XCAN_DLCR_EDL_MASK)
 789                         cf->len = can_dlc2len((dlc & XCAN_DLCR_DLC_MASK) >>
 790                                           XCAN_DLCR_DLC_SHIFT);
 791                 else
 792                         cf->len = get_can_dlc((dlc & XCAN_DLCR_DLC_MASK) >>
 793                                                   XCAN_DLCR_DLC_SHIFT);
 794
 795                 /* Change Xilinx CAN ID format to socketCAN ID format */
 796                 if (id_xcan & XCAN_IDR_IDE_MASK) {
 797                         /* The received frame is an Extended format frame */
 798                         cf->can_id = (id_xcan & XCAN_IDR_ID1_MASK) >> 3;
 799                         cf->can_id |= (id_xcan & XCAN_IDR_ID2_MASK) >>
 800                                         XCAN_IDR_ID2_SHIFT;
 801                         cf->can_id |= CAN_EFF_FLAG;
 802                         if (id_xcan & XCAN_IDR_RTR_MASK)
 803                                 cf->can_id |= CAN_RTR_FLAG;
 804                 } else {
 805                         /* The received frame is a standard format frame */
 806                         cf->can_id = (id_xcan & XCAN_IDR_ID1_MASK) >>
 807                                         XCAN_IDR_ID1_SHIFT;
 808                         if (!(dlc & XCAN_DLCR_EDL_MASK) && (id_xcan &
 809                                                 XCAN_IDR_SRR_MASK))
 810                                 cf->can_id |= CAN_RTR_FLAG;
 811                 }
 812
 813                 /* Check the frame received is FD or not*/
 814                 if (dlc & XCAN_DLCR_EDL_MASK) {
 815                         for (i = 0; i < cf->len; i += 4) {
 816                                 data[0] = priv->read_reg(priv,
 817                                                 (XCANFD_RXDW_OFFSET(readindex) +
 818                                                 (dwindex * XCANFD_DW_BYTES)));
 819                                 *(__be32 *)(cf->data + i) = cpu_to_be32(
 820                                                                 data[0]);
 821                                 dwindex++;
 822                         }
 823                 } else {
 824                         for (i = 0; i < cf->len; i += 4) {
 825                                 data[0] = priv->read_reg(priv,
 826                                         XCANFD_RXDW_OFFSET(readindex) + i);
 827                                 *(__be32 *)(cf->data + i) = cpu_to_be32(
 828                                                         data[0]);
 829                         }
 830                 }
 831                 /* Update FSR Register so that next packet will save to
 832                  * buffer
 833                  */
 834                 fsr = priv->read_reg(priv, XCAN_FSR_OFFSET);
 835                 fsr |= XCAN_FSR_IRI_MASK;
 836                 priv->write_reg(priv, XCAN_FSR_OFFSET, fsr);
 837                 fsr = priv->read_reg(priv, XCAN_FSR_OFFSET);
 838                 stats->rx_bytes += cf->len;
 839                 stats->rx_packets++;
 840                 netif_receive_skb(skb);
 841
 842                 return 1;
 843         }
 844         /* If FSR Register is not updated with fill level */
 845         return 0;
 846 }
 847
 848 static void xcan_chip_stop(struct net_device *ndev);
 849 /**
 850  * xcan_err_interrupt - error frame Isr
 851  * @ndev:       net_device pointer
 852  * @isr:        interrupt status register value
 853  *
 854  * This is the CAN error interrupt and it will
 855  * check the the type of error and forward the error
 856  * frame to upper layers.
 857  */
 858 static void xcan_err_interrupt(struct net_device *ndev, u32 isr)
 859 {
 860         struct xcan_priv *priv = netdev_priv(ndev);
 861         struct net_device_stats *stats = &ndev->stats;
 862         struct can_frame *cf;
 863         struct sk_buff *skb;
 864         u32 err_status, status, txerr = 0, rxerr = 0;
 865
 866         skb = alloc_can_err_skb(ndev, &cf);
 867
 868         err_status = priv->read_reg(priv, XCAN_ESR_OFFSET);
 869         priv->write_reg(priv, XCAN_ESR_OFFSET, err_status);
 870         txerr = priv->read_reg(priv, XCAN_ECR_OFFSET) & XCAN_ECR_TEC_MASK;
 871         rxerr = ((priv->read_reg(priv, XCAN_ECR_OFFSET) &
 872                         XCAN_ECR_REC_MASK) >> XCAN_ESR_REC_SHIFT);
 873         status = priv->read_reg(priv, XCAN_SR_OFFSET);
 874
 875         if (isr & XCAN_IXR_BSOFF_MASK) {
 876                 priv->can.state = CAN_STATE_BUS_OFF;
 877                 priv->can.can_stats.bus_off++;
 878                 /* Leave device in Config Mode in bus-off state */
 879                 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK);
 880                 can_bus_off(ndev);
 881                 if (skb)
 882                         cf->can_id |= CAN_ERR_BUSOFF;
 883         } else if ((status & XCAN_SR_ESTAT_MASK) == XCAN_SR_ESTAT_MASK) {
 884                 priv->can.state = CAN_STATE_ERROR_PASSIVE;
 885                 priv->can.can_stats.error_passive++;
 886                 if (skb) {
 887                         cf->can_id |= CAN_ERR_CRTL;
 888                         cf->data[1] = (rxerr > 127) ?
 889                                         CAN_ERR_CRTL_RX_PASSIVE :
 890                                         CAN_ERR_CRTL_TX_PASSIVE;
 891                         cf->data[6] = txerr;
 892                         cf->data[7] = rxerr;
 893                 }
 894         } else if (status & XCAN_SR_ERRWRN_MASK) {
 895                 priv->can.state = CAN_STATE_ERROR_WARNING;
 896                 priv->can.can_stats.error_warning++;
 897                 if (skb) {
 898                         cf->can_id |= CAN_ERR_CRTL;
 899                         cf->data[1] |= (txerr > rxerr) ?
 900                                         CAN_ERR_CRTL_TX_WARNING :
 901                                         CAN_ERR_CRTL_RX_WARNING;
 902                         cf->data[6] = txerr;
 903                         cf->data[7] = rxerr;
 904                 }
 905         }
 906
 907         /* Check for Arbitration lost interrupt */
 908         if (isr & XCAN_IXR_ARBLST_MASK) {
 909                 priv->can.can_stats.arbitration_lost++;
 910                 if (skb) {
 911                         cf->can_id |= CAN_ERR_LOSTARB;
 912                         cf->data[0] = CAN_ERR_LOSTARB_UNSPEC;
 913                 }
 914         }
 915
 916         /* Check for RX FIFO Overflow interrupt */
 917         if (isr & XCAN_IXR_RXOFLW_MASK) {
 918                 stats->rx_over_errors++;
 919                 stats->rx_errors++;
 920                 xcan_chip_stop(ndev);
 921                 xcan_chip_start(ndev);
 922                 if (skb) {
 923                         cf->can_id |= CAN_ERR_CRTL;
 924                         cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
 925                 }
 926         }
 927
 928         /* Check for error interrupt */
 929         if (isr & XCAN_IXR_ERROR_MASK) {
 930                 if (skb)
 931                         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 932
 933                 /* Check for Ack error interrupt */
 934                 if (err_status & XCAN_ESR_ACKER_MASK) {
 935                         stats->tx_errors++;
 936                         if (skb) {
 937                                 cf->can_id |= CAN_ERR_ACK;
 938                                 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
 939                         }
 940                 }
 941
 942                 /* Check for Bit error interrupt */
 943                 if (err_status & XCAN_ESR_BERR_MASK) {
 944                         stats->tx_errors++;
 945                         if (skb) {
 946                                 cf->can_id |= CAN_ERR_PROT;
 947                                 cf->data[2] = CAN_ERR_PROT_BIT;
 948                         }
 949                 }
 950
 951                 /* Check for Stuff error interrupt */
 952                 if (err_status & XCAN_ESR_STER_MASK) {
 953                         stats->rx_errors++;
 954                         if (skb) {
 955                                 cf->can_id |= CAN_ERR_PROT;
 956                                 cf->data[2] = CAN_ERR_PROT_STUFF;
 957                         }
 958                 }
 959
 960                 /* Check for Form error interrupt */
 961                 if (err_status & XCAN_ESR_FMER_MASK) {
 962                         stats->rx_errors++;
 963                         if (skb) {
 964                                 cf->can_id |= CAN_ERR_PROT;
 965                                 cf->data[2] = CAN_ERR_PROT_FORM;
 966                         }
 967                 }
 968
 969                 /* Check for CRC error interrupt */
 970                 if (err_status & XCAN_ESR_CRCER_MASK) {
 971                         stats->rx_errors++;
 972                         if (skb) {
 973                                 cf->can_id |= CAN_ERR_PROT;
 974                                 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
 975                         }
 976                 }
 977                 if (priv->quirks & CANFD_SUPPORT) {
 978                         /* Check for Fast Bit error interrupt */
 979                         if (err_status & XCAN_ESR_F_BERR_MASK) {
 980                                 stats->tx_errors++;
 981                                 if (skb) {
 982                                         cf->can_id |= CAN_ERR_PROT;
 983                                         cf->data[2] = CAN_ERR_PROT_BIT;
 984                                 }
 985                         }
 986                         /* Check for Stuff error interrupt */
 987                         if (err_status & XCAN_ESR_F_STER_MASK) {
 988                                 stats->rx_errors++;
 989                                 if (skb) {
 990                                         cf->can_id |= CAN_ERR_PROT;
 991                                         cf->data[2] = CAN_ERR_PROT_STUFF;
 992                                 }
 993                         }
 994                         /* Check for Fast Form error interrupt */
 995                         if (err_status & XCAN_ESR_F_FMER_MASK) {
 996                                 stats->rx_errors++;
 997                                 if (skb) {
 998                                         cf->can_id |= CAN_ERR_PROT;
 999                                         cf->data[2] = CAN_ERR_PROT_FORM;
1000                                 }
1001                         }
1002                         if (err_status & XCAN_ESR_F_CRCER_MASK) {
1003                                 stats->rx_errors++;
1004                                 if (skb) {
1005                                         cf->can_id |= CAN_ERR_PROT;
1006                                         priv->can.can_stats.bus_error++;
1007                                 }
1008                         }
1009                 }
1010                 priv->can.can_stats.bus_error++;
1011         }
1012
1013         if (skb) {
1014                 stats->rx_packets++;
1015                 stats->rx_bytes += cf->can_dlc;
1016                 netif_rx(skb);
1017         }
1018
1019         netdev_dbg(ndev, "%s: error status register:0x%x\n",
1020                    __func__, priv->read_reg(priv, XCAN_ESR_OFFSET));
1021 }
1022
1023 /**
1024  * xcan_state_interrupt - It will check the state of the CAN device
1025  * @ndev:       net_device pointer
1026  * @isr:        interrupt status register value
1027  *
1028  * This will checks the state of the CAN device
1029  * and puts the device into appropriate state.
1030  */
1031 static void xcan_state_interrupt(struct net_device *ndev, u32 isr)
1032 {
1033         struct xcan_priv *priv = netdev_priv(ndev);
1034
1035         /* Check for Sleep interrupt if set put CAN device in sleep state */
1036         if (isr & XCAN_IXR_SLP_MASK)
1037                 priv->can.state = CAN_STATE_SLEEPING;
1038
1039         /* Check for Wake up interrupt if set put CAN device in Active state */
1040         if (isr & XCAN_IXR_WKUP_MASK)
1041                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
1042 }
1043
1044 /**
1045  * xcan_rx_poll - Poll routine for rx packets (NAPI)
1046  * @napi:       napi structure pointer
1047  * @quota:      Max number of rx packets to be processed.
1048  *
1049  * This is the poll routine for rx part.
1050  * It will process the packets maximux quota value.
1051  *
1052  * Return: number of packets received
1053  */
1054 static int xcan_rx_poll(struct napi_struct *napi, int quota)
1055 {
1056         struct net_device *ndev = napi->dev;
1057         struct xcan_priv *priv = netdev_priv(ndev);
1058         u32 isr, ier;
1059         int work_done = 0, rx_bit_mask;
1060
1061         isr = priv->read_reg(priv, XCAN_ISR_OFFSET);
1062         rx_bit_mask = ((priv->quirks & CANFD_SUPPORT) ?
1063                         XCAN_IXR_RXOK_MASK : XCAN_IXR_RXNEMP_MASK);
1064         while ((isr & rx_bit_mask) && (work_done < quota)) {
1065                 if (rx_bit_mask & XCAN_IXR_RXOK_MASK)
1066                         work_done += xcanfd_rx(ndev);
1067                 else
1068                         work_done += xcan_rx(ndev);
1069                 priv->write_reg(priv, XCAN_ICR_OFFSET, rx_bit_mask);
1070                 isr = priv->read_reg(priv, XCAN_ISR_OFFSET);
1071         }
1072
1073         if (work_done)
1074                 can_led_event(ndev, CAN_LED_EVENT_RX);
1075
1076         if (work_done < quota) {
1077                 napi_complete(napi);
1078                 ier = priv->read_reg(priv, XCAN_IER_OFFSET);
1079                 ier |= rx_bit_mask;
1080                 priv->write_reg(priv, XCAN_IER_OFFSET, ier);
1081         }
1082         return work_done;
1083 }
1084
1085 /**
1086  * xcan_tx_interrupt - Tx Done Isr
1087  * @ndev:       net_device pointer
1088  * @isr:        Interrupt status register value
1089  */
1090 static void xcan_tx_interrupt(struct net_device *ndev, u32 isr)
1091 {
1092         struct xcan_priv *priv = netdev_priv(ndev);
1093         struct net_device_stats *stats = &ndev->stats;
1094
1095         while ((priv->tx_head - priv->tx_tail > 0) &&
1096                (isr & XCAN_IXR_TXOK_MASK)) {
1097                 priv->write_reg(priv, XCAN_ICR_OFFSET, XCAN_IXR_TXOK_MASK);
1098                 can_get_echo_skb(ndev, priv->tx_tail %
1099                                         priv->tx_max);
1100                 priv->tx_tail++;
1101                 stats->tx_packets++;
1102                 isr = priv->read_reg(priv, XCAN_ISR_OFFSET);
1103         }
1104         can_led_event(ndev, CAN_LED_EVENT_TX);
1105         netif_wake_queue(ndev);
1106 }
1107
1108 /**
1109  * xcan_interrupt - CAN Isr
1110  * @irq:        irq number
1111  * @dev_id:     device id poniter
1112  *
1113  * This is the xilinx CAN Isr. It checks for the type of interrupt
1114  * and invokes the corresponding ISR.
1115  *
1116  * Return:
1117  * IRQ_NONE - If CAN device is in sleep mode, IRQ_HANDLED otherwise
1118  */
1119 static irqreturn_t xcan_interrupt(int irq, void *dev_id)
1120 {
1121         struct net_device *ndev = (struct net_device *)dev_id;
1122         struct xcan_priv *priv = netdev_priv(ndev);
1123         u32 isr, ier, rx_bit_mask;
1124
1125         /* Get the interrupt status from Xilinx CAN */
1126         isr = priv->read_reg(priv, XCAN_ISR_OFFSET);
1127         if (!isr)
1128                 return IRQ_NONE;
1129
1130         /* Check for the type of interrupt and Processing it */
1131         if (isr & (XCAN_IXR_SLP_MASK | XCAN_IXR_WKUP_MASK)) {
1132                 priv->write_reg(priv, XCAN_ICR_OFFSET, (XCAN_IXR_SLP_MASK |
1133                                 XCAN_IXR_WKUP_MASK));
1134                 xcan_state_interrupt(ndev, isr);
1135         }
1136
1137         /* Check for Tx interrupt and Processing it */
1138         if (isr & XCAN_IXR_TXOK_MASK)
1139                 xcan_tx_interrupt(ndev, isr);
1140
1141         /* Check for the type of error interrupt and Processing it */
1142         if (isr & (XCAN_IXR_ERROR_MASK | XCAN_IXR_RXOFLW_MASK |
1143                         XCAN_IXR_BSOFF_MASK | XCAN_IXR_ARBLST_MASK)) {
1144                 priv->write_reg(priv, XCAN_ICR_OFFSET, (XCAN_IXR_ERROR_MASK |
1145                                 XCAN_IXR_RXOFLW_MASK | XCAN_IXR_BSOFF_MASK |
1146                                 XCAN_IXR_ARBLST_MASK));
1147                 xcan_err_interrupt(ndev, isr);
1148         }
1149         if (priv->quirks & CANFD_SUPPORT) {
1150                 if (isr & (XCAN_IXR_RXMNF_MASK | XCAN_IXR_TXRRS_MASK |
1151                         XCAN_IXR_PEE_MASK | XCAN_IXR_BSRD_MASK)) {
1152                         priv->write_reg(priv, XCAN_ICR_OFFSET,
1153                                         (XCAN_IXR_RXMNF_MASK |
1154                                          XCAN_IXR_TXRRS_MASK |
1155                                         XCAN_IXR_PEE_MASK |
1156                                         XCAN_IXR_BSRD_MASK));
1157                         xcan_err_interrupt(ndev, isr);
1158                 }
1159         }
1160         /* Check for the type of receive interrupt and Processing it */
1161         rx_bit_mask = ((priv->quirks & CANFD_SUPPORT) ?
1162                         XCAN_IXR_RXOK_MASK : XCAN_IXR_RXNEMP_MASK);
1163         if (isr & rx_bit_mask) {
1164                 ier = priv->read_reg(priv, XCAN_IER_OFFSET);
1165                 ier &= ~(rx_bit_mask);
1166                 priv->write_reg(priv, XCAN_IER_OFFSET, ier);
1167                 napi_schedule(&priv->napi);
1168         }
1169         return IRQ_HANDLED;
1170 }
1171
1172 /**
1173  * xcan_chip_stop - Driver stop routine
1174  * @ndev:       Pointer to net_device structure
1175  *
1176  * This is the drivers stop routine. It will disable the
1177  * interrupts and put the device into configuration mode.
1178  */
1179 static void xcan_chip_stop(struct net_device *ndev)
1180 {
1181         struct xcan_priv *priv = netdev_priv(ndev);
1182         u32 ier, intr_all = 0;
1183
1184         /* Disable interrupts and leave the can in configuration mode */
1185         ier = priv->read_reg(priv, XCAN_IER_OFFSET);
1186         if (priv->quirks & CANFD_SUPPORT) {
1187                 intr_all = XCAN_INTR_ALL | XCAN_IXR_PEE_MASK |
1188                                 XCAN_IXR_BSRD_MASK | XCAN_IXR_RXMNF_MASK |
1189                                 XCAN_IXR_TXRRS_MASK | XCAN_IXR_RXOK_MASK;
1190         } else {
1191                 intr_all = XCAN_INTR_ALL | XCAN_IXR_RXNEMP_MASK;
1192         }
1193
1194         ier &= ~intr_all;
1195         priv->write_reg(priv, XCAN_IER_OFFSET, ier);
1196         priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK);
1197         priv->can.state = CAN_STATE_STOPPED;
1198 }
1199
1200 /**
1201  * xcan_open - Driver open routine
1202  * @ndev:       Pointer to net_device structure
1203  *
1204  * This is the driver open routine.
1205  * Return: 0 on success and failure value on error
1206  */
1207 static int xcan_open(struct net_device *ndev)
1208 {
1209         struct xcan_priv *priv = netdev_priv(ndev);
1210         int ret;
1211
1212         ret = pm_runtime_get_sync(priv->dev);
1213         if (ret < 0) {
1214                 netdev_err(ndev, "%s: pm_runtime_get failed(%d)\n",
1215                            __func__, ret);
1216                 return ret;
1217         }
1218
1219         ret = request_irq(ndev->irq, xcan_interrupt, priv->irq_flags,
1220                           ndev->name, ndev);
1221         if (ret < 0) {
1222                 netdev_err(ndev, "irq allocation for CAN failed\n");
1223                 goto err;
1224         }
1225
1226         /* Set chip into reset mode */
1227         ret = set_reset_mode(ndev);
1228         if (ret < 0) {
1229                 netdev_err(ndev, "mode resetting failed!\n");
1230                 goto err_irq;
1231         }
1232
1233         /* Common open */
1234         ret = open_candev(ndev);
1235         if (ret)
1236                 goto err_irq;
1237
1238         ret = xcan_chip_start(ndev);
1239         if (ret < 0) {
1240                 netdev_err(ndev, "xcan_chip_start failed!\n");
1241                 goto err_candev;
1242         }
1243
1244         can_led_event(ndev, CAN_LED_EVENT_OPEN);
1245         napi_enable(&priv->napi);
1246         netif_start_queue(ndev);
1247
1248         return 0;
1249
1250 err_candev:
1251         close_candev(ndev);
1252 err_irq:
1253         free_irq(ndev->irq, ndev);
1254 err:
1255         pm_runtime_put(priv->dev);
1256
1257         return ret;
1258 }
1259
1260 /**
1261  * xcan_close - Driver close routine
1262  * @ndev:       Pointer to net_device structure
1263  *
1264  * Return: 0 always
1265  */
1266 static int xcan_close(struct net_device *ndev)
1267 {
1268         struct xcan_priv *priv = netdev_priv(ndev);
1269
1270         netif_stop_queue(ndev);
1271         napi_disable(&priv->napi);
1272         xcan_chip_stop(ndev);
1273         free_irq(ndev->irq, ndev);
1274         close_candev(ndev);
1275
1276         can_led_event(ndev, CAN_LED_EVENT_STOP);
1277         pm_runtime_put(priv->dev);
1278
1279         return 0;
1280 }
1281
1282 /**
1283  * xcan_get_berr_counter - error counter routine
1284  * @ndev:       Pointer to net_device structure
1285  * @bec:        Pointer to can_berr_counter structure
1286  *
1287  * This is the driver error counter routine.
1288  * Return: 0 on success and failure value on error
1289  */
1290 static int xcan_get_berr_counter(const struct net_device *ndev,
1291                                  struct can_berr_counter *bec)
1292 {
1293         struct xcan_priv *priv = netdev_priv(ndev);
1294         int ret;
1295
1296         ret = pm_runtime_get_sync(priv->dev);
1297         if (ret < 0) {
1298                 netdev_err(ndev, "%s: pm_runtime_get failed(%d)\n",
1299                            __func__, ret);
1300                 return ret;
1301         }
1302
1303         bec->txerr = priv->read_reg(priv, XCAN_ECR_OFFSET) & XCAN_ECR_TEC_MASK;
1304         bec->rxerr = ((priv->read_reg(priv, XCAN_ECR_OFFSET) &
1305                         XCAN_ECR_REC_MASK) >> XCAN_ESR_REC_SHIFT);
1306
1307         pm_runtime_put(priv->dev);
1308
1309         return 0;
1310 }
1311
1312 static const struct net_device_ops xcan_netdev_ops = {
1313         .ndo_open       = xcan_open,
1314         .ndo_stop       = xcan_close,
1315         .ndo_start_xmit = xcan_start_xmit,
1316         .ndo_change_mtu = can_change_mtu,
1317 };
1318
1319 /**
1320  * xcan_suspend - Suspend method for the driver
1321  * @dev:        Address of the device structure
1322  *
1323  * Put the driver into low power mode.
1324  * Return: 0 on success and failure value on error
1325  */
1326 static int __maybe_unused xcan_suspend(struct device *dev)
1327 {
1328         struct net_device *netdev = dev_get_drvdata(dev);
1329
1330         if (!device_may_wakeup(dev)) {
1331                 if (netif_running(netdev))
1332                         xcan_close(netdev);
1333                 return pm_runtime_force_suspend(dev);
1334         }
1335
1336         return 0;
1337 }
1338
1339 /**
1340  * xcan_resume - Resume from suspend
1341  * @dev:        Address of the device structure
1342  *
1343  * Resume operation after suspend.
1344  * Return: 0 on success and failure value on error
1345  */
1346 static int __maybe_unused xcan_resume(struct device *dev)
1347 {
1348         int ret;
1349         struct net_device *netdev = dev_get_drvdata(dev);
1350
1351         if (!device_may_wakeup(dev)) {
1352                 ret = pm_runtime_force_resume(dev);
1353                 if (netif_running(netdev))
1354                         xcan_open(netdev);
1355                 return ret;
1356         }
1357
1358         return 0;
1359 }
1360
1361 /**
1362  * xcan_runtime_suspend - Runtime suspend method for the driver
1363  * @dev:        Address of the device structure
1364  *
1365  * Put the driver into low power mode.
1366  * Return: 0 always
1367  */
1368 static int __maybe_unused xcan_runtime_suspend(struct device *dev)
1369 {
1370         struct net_device *ndev = dev_get_drvdata(dev);
1371         struct xcan_priv *priv = netdev_priv(ndev);
1372
1373         if (netif_running(ndev)) {
1374                 netif_stop_queue(ndev);
1375                 netif_device_detach(ndev);
1376         }
1377
1378         priv->write_reg(priv, XCAN_MSR_OFFSET, XCAN_MSR_SLEEP_MASK);
1379         priv->can.state = CAN_STATE_SLEEPING;
1380
1381         clk_disable_unprepare(priv->bus_clk);
1382         clk_disable_unprepare(priv->can_clk);
1383
1384         return 0;
1385 }
1386
1387 /**
1388  * xcan_runtime_resume - Runtime resume from suspend
1389  * @dev:        Address of the device structure
1390  *
1391  * Resume operation after suspend.
1392  * Return: 0 on success and failure value on error
1393  */
1394 static int __maybe_unused xcan_runtime_resume(struct device *dev)
1395 {
1396         struct net_device *ndev = dev_get_drvdata(dev);
1397         struct xcan_priv *priv = netdev_priv(ndev);
1398         int ret;
1399         u32 isr, status;
1400
1401         ret = clk_prepare_enable(priv->bus_clk);
1402         if (ret) {
1403                 dev_err(dev, "Cannot enable clock.\n");
1404                 return ret;
1405         }
1406         ret = clk_prepare_enable(priv->can_clk);
1407         if (ret) {
1408                 dev_err(dev, "Cannot enable clock.\n");
1409                 clk_disable_unprepare(priv->bus_clk);
1410                 return ret;
1411         }
1412
1413         priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK);
1414         isr = priv->read_reg(priv, XCAN_ISR_OFFSET);
1415         status = priv->read_reg(priv, XCAN_SR_OFFSET);
1416
1417         if (netif_running(ndev)) {
1418                 if (isr & XCAN_IXR_BSOFF_MASK) {
1419                         priv->can.state = CAN_STATE_BUS_OFF;
1420                         priv->write_reg(priv, XCAN_SRR_OFFSET,
1421                                         XCAN_SRR_RESET_MASK);
1422                 } else if ((status & XCAN_SR_ESTAT_MASK) ==
1423                                         XCAN_SR_ESTAT_MASK) {
1424                         priv->can.state = CAN_STATE_ERROR_PASSIVE;
1425                 } else if (status & XCAN_SR_ERRWRN_MASK) {
1426                         priv->can.state = CAN_STATE_ERROR_WARNING;
1427                 } else {
1428                         priv->can.state = CAN_STATE_ERROR_ACTIVE;
1429                 }
1430                 netif_device_attach(ndev);
1431                 netif_start_queue(ndev);
1432         }
1433
1434         return 0;
1435 }
1436
1437 static const struct dev_pm_ops xcan_dev_pm_ops = {
1438         SET_SYSTEM_SLEEP_PM_OPS(xcan_suspend, xcan_resume)
1439         SET_RUNTIME_PM_OPS(xcan_runtime_suspend, xcan_runtime_resume, NULL)
1440 };
1441
1442 static const struct xcan_platform_data xcan_def = {
1443         .quirks = CANFD_SUPPORT,
1444 };
1445
1446 /* Match table for OF platform binding */
1447 static const struct of_device_id xcan_of_match[] = {
1448         { .compatible = "xlnx,zynq-can-1.0", },
1449         { .compatible = "xlnx,axi-can-1.00.a", },
1450         { .compatible = "xlnx,canfd-1.0", .data = &xcan_def },
1451         { /* end of list */ },
1452 };
1453 MODULE_DEVICE_TABLE(of, xcan_of_match);
1454
1455 /**
1456  * xcan_probe - Platform registration call
1457  * @pdev:       Handle to the platform device structure
1458  *
1459  * This function does all the memory allocation and registration for the CAN
1460  * device.
1461  *
1462  * Return: 0 on success and failure value on error
1463  */
1464 static int xcan_probe(struct platform_device *pdev)
1465 {
1466         struct resource *res; /* IO mem resources */
1467         struct net_device *ndev;
1468         struct xcan_priv *priv;
1469         const struct of_device_id *match;
1470         void __iomem *addr;
1471         int ret, rx_max, tx_max;
1472
1473         /* Get the virtual base address for the device */
1474         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1475         addr = devm_ioremap_resource(&pdev->dev, res);
1476         if (IS_ERR(addr)) {
1477                 ret = PTR_ERR(addr);
1478                 goto err;
1479         }
1480
1481         ret = of_property_read_u32(pdev->dev.of_node, "tx-fifo-depth", &tx_max);
1482         if (ret < 0)
1483                 goto err;
1484
1485         ret = of_property_read_u32(pdev->dev.of_node, "rx-fifo-depth", &rx_max);
1486         if (ret < 0)
1487                 goto err;
1488
1489         /* Create a CAN device instance */
1490         ndev = alloc_candev(sizeof(struct xcan_priv), tx_max);
1491         if (!ndev)
1492                 return -ENOMEM;
1493
1494         priv = netdev_priv(ndev);
1495
1496         match = of_match_node(xcan_of_match, pdev->dev.of_node);
1497         if (match && match->data) {
1498                 const struct xcan_platform_data *data = match->data;
1499
1500                 priv->quirks = data->quirks;
1501         }
1502
1503         priv->dev = &pdev->dev;
1504         priv->can.bittiming_const = &xcan_bittiming_const;
1505         priv->can.do_set_mode = xcan_do_set_mode;
1506         priv->can.do_get_berr_counter = xcan_get_berr_counter;
1507         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
1508                                         CAN_CTRLMODE_BERR_REPORTING;
1509         if (priv->quirks & CANFD_SUPPORT) {
1510                 priv->can.data_bittiming_const = &xcan_data_bittiming_const;
1511                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD;
1512                 xcan_bittiming_const.tseg1_max = 64;
1513                 xcan_bittiming_const.tseg2_max = 16;
1514                 xcan_bittiming_const.sjw_max = 16;
1515         }
1516         priv->reg_base = addr;
1517         priv->tx_max = tx_max;
1518         priv->tx_head = 0;
1519         priv->tx_tail = 0;
1520
1521         /* Get IRQ for the device */
1522         ndev->irq = platform_get_irq(pdev, 0);
1523         ndev->flags |= IFF_ECHO;        /* We support local echo */
1524
1525         platform_set_drvdata(pdev, ndev);
1526         SET_NETDEV_DEV(ndev, &pdev->dev);
1527         ndev->netdev_ops = &xcan_netdev_ops;
1528
1529         /* Getting the CAN can_clk info */
1530         priv->can_clk = devm_clk_get(&pdev->dev, "can_clk");
1531         if (IS_ERR(priv->can_clk)) {
1532                 dev_err(&pdev->dev, "Device clock not found.\n");
1533                 ret = PTR_ERR(priv->can_clk);
1534                 goto err_free;
1535         }
1536         /* Check for type of CAN device */
1537         if (of_device_is_compatible(pdev->dev.of_node,
1538                                     "xlnx,zynq-can-1.0")) {
1539                 priv->bus_clk = devm_clk_get(&pdev->dev, "pclk");
1540                 if (IS_ERR(priv->bus_clk)) {
1541                         dev_err(&pdev->dev, "bus clock not found\n");
1542                         ret = PTR_ERR(priv->bus_clk);
1543                         goto err_free;
1544                 }
1545         } else {
1546                 priv->bus_clk = devm_clk_get(&pdev->dev, "s_axi_aclk");
1547                 if (IS_ERR(priv->bus_clk)) {
1548                         dev_err(&pdev->dev, "bus clock not found\n");
1549                         ret = PTR_ERR(priv->bus_clk);
1550                         goto err_free;
1551                 }
1552         }
1553
1554         priv->write_reg = xcan_write_reg_le;
1555         priv->read_reg = xcan_read_reg_le;
1556
1557         ret = clk_prepare_enable(priv->bus_clk);
1558         if (ret) {
1559                 dev_err(&pdev->dev, "Cannot enable clock.\n");
1560                 goto err_free;
1561         }
1562
1563         ret = clk_prepare_enable(priv->can_clk);
1564         if (ret) {
1565                 dev_err(&pdev->dev, "Cannot enable clock.\n");
1566                 goto err_clk;
1567         }
1568
1569         pm_runtime_set_active(&pdev->dev);
1570         pm_runtime_enable(&pdev->dev);
1571         pm_runtime_get_sync(&pdev->dev);
1572
1573         if (priv->read_reg(priv, XCAN_SR_OFFSET) != XCAN_SR_CONFIG_MASK) {
1574                 priv->write_reg = xcan_write_reg_be;
1575                 priv->read_reg = xcan_read_reg_be;
1576         }
1577
1578         priv->can.clock.freq = clk_get_rate(priv->can_clk);
1579
1580         netif_napi_add(ndev, &priv->napi, xcan_rx_poll, rx_max);
1581
1582         ret = register_candev(ndev);
1583         if (ret) {
1584                 dev_err(&pdev->dev, "fail to register failed (err=%d)\n", ret);
1585                 goto err_disableclks;
1586         }
1587
1588         devm_can_led_init(ndev);
1589
1590         pm_runtime_put(&pdev->dev);
1591
1592         netdev_dbg(ndev, "reg_base=0x%p irq=%d clock=%d, tx fifo depth:%d\n",
1593                    priv->reg_base, ndev->irq, priv->can.clock.freq,
1594                    priv->tx_max);
1595
1596         return 0;
1597
1598 err_disableclks:
1599         pm_runtime_disable(&pdev->dev);
1600         pm_runtime_set_suspended(&pdev->dev);
1601         clk_disable_unprepare(priv->can_clk);
1602 err_clk:
1603         clk_disable_unprepare(priv->bus_clk);
1604 err_free:
1605         free_candev(ndev);
1606 err:
1607         return ret;
1608 }
1609
1610 /**
1611  * xcan_remove - Unregister the device after releasing the resources
1612  * @pdev:       Handle to the platform device structure
1613  *
1614  * This function frees all the resources allocated to the device.
1615  * Return: 0 always
1616  */
1617 static int xcan_remove(struct platform_device *pdev)
1618 {
1619         struct net_device *ndev = platform_get_drvdata(pdev);
1620         struct xcan_priv *priv = netdev_priv(ndev);
1621
1622         unregister_candev(ndev);
1623
1624         if (!pm_runtime_suspended(&pdev->dev)) {
1625                 clk_disable_unprepare(priv->bus_clk);
1626                 clk_disable_unprepare(priv->can_clk);
1627         }
1628
1629         pm_runtime_disable(&pdev->dev);
1630         netif_napi_del(&priv->napi);
1631         free_candev(ndev);
1632
1633         return 0;
1634 }
1635
1636 static struct platform_driver xcan_driver = {
1637         .probe = xcan_probe,
1638         .remove = xcan_remove,
1639         .driver = {
1640                 .name = DRIVER_NAME,
1641                 .pm = &xcan_dev_pm_ops,
1642                 .of_match_table = xcan_of_match,
1643         },
1644 };
1645
1646 module_platform_driver(xcan_driver);
1647
1648 MODULE_LICENSE("GPL");
1649 MODULE_AUTHOR("Xilinx Inc");
1650 MODULE_DESCRIPTION("Xilinx CAN interface");