drivers/net/can/ifi_canfd/ifi_canfd.c

   1 /*
   2  * CAN bus driver for IFI CANFD controller
   3  *
   4  * Copyright (C) 2016 Marek Vasut <marex@denx.de>
   5  *
   6  * Details about this controller can be found at
   7  * http://www.ifi-pld.de/IP/CANFD/canfd.html
   8  *
   9  * This file is licensed under the terms of the GNU General Public
  10  * License version 2. This program is licensed "as is" without any
  11  * warranty of any kind, whether express or implied.
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/delay.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/io.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/of.h>
  22 #include <linux/of_device.h>
  23 #include <linux/platform_device.h>
  24
  25 #include <linux/can/dev.h>
  26
  27 #define IFI_CANFD_STCMD                         0x0
  28 #define IFI_CANFD_STCMD_HARDRESET               0xDEADCAFD
  29 #define IFI_CANFD_STCMD_ENABLE                  BIT(0)
  30 #define IFI_CANFD_STCMD_ERROR_ACTIVE            BIT(2)
  31 #define IFI_CANFD_STCMD_ERROR_PASSIVE           BIT(3)
  32 #define IFI_CANFD_STCMD_BUSOFF                  BIT(4)
  33 #define IFI_CANFD_STCMD_BUSMONITOR              BIT(16)
  34 #define IFI_CANFD_STCMD_LOOPBACK                BIT(18)
  35 #define IFI_CANFD_STCMD_DISABLE_CANFD           BIT(24)
  36 #define IFI_CANFD_STCMD_ENABLE_ISO              BIT(25)
  37 #define IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING   BIT(26)
  38 #define IFI_CANFD_STCMD_NORMAL_MODE             ((u32)BIT(31))
  39
  40 #define IFI_CANFD_RXSTCMD                       0x4
  41 #define IFI_CANFD_RXSTCMD_REMOVE_MSG            BIT(0)
  42 #define IFI_CANFD_RXSTCMD_RESET                 BIT(7)
  43 #define IFI_CANFD_RXSTCMD_EMPTY                 BIT(8)
  44 #define IFI_CANFD_RXSTCMD_OVERFLOW              BIT(13)
  45
  46 #define IFI_CANFD_TXSTCMD                       0x8
  47 #define IFI_CANFD_TXSTCMD_ADD_MSG               BIT(0)
  48 #define IFI_CANFD_TXSTCMD_HIGH_PRIO             BIT(1)
  49 #define IFI_CANFD_TXSTCMD_RESET                 BIT(7)
  50 #define IFI_CANFD_TXSTCMD_EMPTY                 BIT(8)
  51 #define IFI_CANFD_TXSTCMD_FULL                  BIT(12)
  52 #define IFI_CANFD_TXSTCMD_OVERFLOW              BIT(13)
  53
  54 #define IFI_CANFD_INTERRUPT                     0xc
  55 #define IFI_CANFD_INTERRUPT_ERROR_WARNING       BIT(1)
  56 #define IFI_CANFD_INTERRUPT_ERROR_COUNTER       BIT(10)
  57 #define IFI_CANFD_INTERRUPT_TXFIFO_EMPTY        BIT(16)
  58 #define IFI_CANFD_INTERRUPT_TXFIFO_REMOVE       BIT(22)
  59 #define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY       BIT(24)
  60 #define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER   BIT(25)
  61 #define IFI_CANFD_INTERRUPT_SET_IRQ             ((u32)BIT(31))
  62
  63 #define IFI_CANFD_IRQMASK                       0x10
  64 #define IFI_CANFD_IRQMASK_SET_ERR               BIT(7)
  65 #define IFI_CANFD_IRQMASK_SET_TS                BIT(15)
  66 #define IFI_CANFD_IRQMASK_TXFIFO_EMPTY          BIT(16)
  67 #define IFI_CANFD_IRQMASK_SET_TX                BIT(23)
  68 #define IFI_CANFD_IRQMASK_RXFIFO_NEMPTY         BIT(24)
  69 #define IFI_CANFD_IRQMASK_SET_RX                ((u32)BIT(31))
  70
  71 #define IFI_CANFD_TIME                          0x14
  72 #define IFI_CANFD_FTIME                         0x18
  73 #define IFI_CANFD_TIME_TIMEB_OFF                0
  74 #define IFI_CANFD_TIME_TIMEA_OFF                8
  75 #define IFI_CANFD_TIME_PRESCALE_OFF             16
  76 #define IFI_CANFD_TIME_SJW_OFF_7_9_8_8          25
  77 #define IFI_CANFD_TIME_SJW_OFF_4_12_6_6         28
  78 #define IFI_CANFD_TIME_SET_SJW_4_12_6_6         BIT(6)
  79 #define IFI_CANFD_TIME_SET_TIMEB_4_12_6_6       BIT(7)
  80 #define IFI_CANFD_TIME_SET_PRESC_4_12_6_6       BIT(14)
  81 #define IFI_CANFD_TIME_SET_TIMEA_4_12_6_6       BIT(15)
  82
  83 #define IFI_CANFD_TDELAY                        0x1c
  84 #define IFI_CANFD_TDELAY_DEFAULT                0xb
  85 #define IFI_CANFD_TDELAY_MASK                   0x3fff
  86 #define IFI_CANFD_TDELAY_ABS                    BIT(14)
  87 #define IFI_CANFD_TDELAY_EN                     BIT(15)
  88
  89 #define IFI_CANFD_ERROR                         0x20
  90 #define IFI_CANFD_ERROR_TX_OFFSET               0
  91 #define IFI_CANFD_ERROR_TX_MASK                 0xff
  92 #define IFI_CANFD_ERROR_RX_OFFSET               16
  93 #define IFI_CANFD_ERROR_RX_MASK                 0xff
  94
  95 #define IFI_CANFD_ERRCNT                        0x24
  96
  97 #define IFI_CANFD_SUSPEND                       0x28
  98
  99 #define IFI_CANFD_REPEAT                        0x2c
 100
 101 #define IFI_CANFD_TRAFFIC                       0x30
 102
 103 #define IFI_CANFD_TSCONTROL                     0x34
 104
 105 #define IFI_CANFD_TSC                           0x38
 106
 107 #define IFI_CANFD_TST                           0x3c
 108
 109 #define IFI_CANFD_RES1                          0x40
 110
 111 #define IFI_CANFD_ERROR_CTR                     0x44
 112 #define IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC        0x21302899
 113 #define IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST      BIT(0)
 114 #define IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST     BIT(1)
 115 #define IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST    BIT(2)
 116 #define IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST    BIT(3)
 117 #define IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST   BIT(4)
 118 #define IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST     BIT(5)
 119 #define IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST    BIT(6)
 120 #define IFI_CANFD_ERROR_CTR_OVERLOAD_ALL        BIT(8)
 121 #define IFI_CANFD_ERROR_CTR_ACK_ERROR_ALL       BIT(9)
 122 #define IFI_CANFD_ERROR_CTR_BIT0_ERROR_ALL      BIT(10)
 123 #define IFI_CANFD_ERROR_CTR_BIT1_ERROR_ALL      BIT(11)
 124 #define IFI_CANFD_ERROR_CTR_STUFF_ERROR_ALL     BIT(12)
 125 #define IFI_CANFD_ERROR_CTR_CRC_ERROR_ALL       BIT(13)
 126 #define IFI_CANFD_ERROR_CTR_FORM_ERROR_ALL      BIT(14)
 127 #define IFI_CANFD_ERROR_CTR_BITPOSITION_OFFSET  16
 128 #define IFI_CANFD_ERROR_CTR_BITPOSITION_MASK    0xff
 129 #define IFI_CANFD_ERROR_CTR_ER_RESET            BIT(30)
 130 #define IFI_CANFD_ERROR_CTR_ER_ENABLE           ((u32)BIT(31))
 131
 132 #define IFI_CANFD_PAR                           0x48
 133
 134 #define IFI_CANFD_CANCLOCK                      0x4c
 135
 136 #define IFI_CANFD_SYSCLOCK                      0x50
 137
 138 #define IFI_CANFD_VER                           0x54
 139 #define IFI_CANFD_VER_REV_MASK                  0xff
 140 #define IFI_CANFD_VER_REV_MIN_SUPPORTED         0x15
 141
 142 #define IFI_CANFD_IP_ID                         0x58
 143 #define IFI_CANFD_IP_ID_VALUE                   0xD073CAFD
 144
 145 #define IFI_CANFD_TEST                          0x5c
 146
 147 #define IFI_CANFD_RXFIFO_TS_63_32               0x60
 148
 149 #define IFI_CANFD_RXFIFO_TS_31_0                0x64
 150
 151 #define IFI_CANFD_RXFIFO_DLC                    0x68
 152 #define IFI_CANFD_RXFIFO_DLC_DLC_OFFSET         0
 153 #define IFI_CANFD_RXFIFO_DLC_DLC_MASK           0xf
 154 #define IFI_CANFD_RXFIFO_DLC_RTR                BIT(4)
 155 #define IFI_CANFD_RXFIFO_DLC_EDL                BIT(5)
 156 #define IFI_CANFD_RXFIFO_DLC_BRS                BIT(6)
 157 #define IFI_CANFD_RXFIFO_DLC_ESI                BIT(7)
 158 #define IFI_CANFD_RXFIFO_DLC_OBJ_OFFSET         8
 159 #define IFI_CANFD_RXFIFO_DLC_OBJ_MASK           0x1ff
 160 #define IFI_CANFD_RXFIFO_DLC_FNR_OFFSET         24
 161 #define IFI_CANFD_RXFIFO_DLC_FNR_MASK           0xff
 162
 163 #define IFI_CANFD_RXFIFO_ID                     0x6c
 164 #define IFI_CANFD_RXFIFO_ID_ID_OFFSET           0
 165 #define IFI_CANFD_RXFIFO_ID_ID_STD_MASK         CAN_SFF_MASK
 166 #define IFI_CANFD_RXFIFO_ID_ID_STD_OFFSET       0
 167 #define IFI_CANFD_RXFIFO_ID_ID_STD_WIDTH        10
 168 #define IFI_CANFD_RXFIFO_ID_ID_XTD_MASK         CAN_EFF_MASK
 169 #define IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET       11
 170 #define IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH        18
 171 #define IFI_CANFD_RXFIFO_ID_IDE                 BIT(29)
 172
 173 #define IFI_CANFD_RXFIFO_DATA                   0x70    /* 0x70..0xac */
 174
 175 #define IFI_CANFD_TXFIFO_SUSPEND_US             0xb0
 176
 177 #define IFI_CANFD_TXFIFO_REPEATCOUNT            0xb4
 178
 179 #define IFI_CANFD_TXFIFO_DLC                    0xb8
 180 #define IFI_CANFD_TXFIFO_DLC_DLC_OFFSET         0
 181 #define IFI_CANFD_TXFIFO_DLC_DLC_MASK           0xf
 182 #define IFI_CANFD_TXFIFO_DLC_RTR                BIT(4)
 183 #define IFI_CANFD_TXFIFO_DLC_EDL                BIT(5)
 184 #define IFI_CANFD_TXFIFO_DLC_BRS                BIT(6)
 185 #define IFI_CANFD_TXFIFO_DLC_FNR_OFFSET         24
 186 #define IFI_CANFD_TXFIFO_DLC_FNR_MASK           0xff
 187
 188 #define IFI_CANFD_TXFIFO_ID                     0xbc
 189 #define IFI_CANFD_TXFIFO_ID_ID_OFFSET           0
 190 #define IFI_CANFD_TXFIFO_ID_ID_STD_MASK         CAN_SFF_MASK
 191 #define IFI_CANFD_TXFIFO_ID_ID_STD_OFFSET       0
 192 #define IFI_CANFD_TXFIFO_ID_ID_STD_WIDTH        10
 193 #define IFI_CANFD_TXFIFO_ID_ID_XTD_MASK         CAN_EFF_MASK
 194 #define IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET       11
 195 #define IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH        18
 196 #define IFI_CANFD_TXFIFO_ID_IDE                 BIT(29)
 197
 198 #define IFI_CANFD_TXFIFO_DATA                   0xc0    /* 0xb0..0xfc */
 199
 200 #define IFI_CANFD_FILTER_MASK(n)                (0x800 + ((n) * 8) + 0)
 201 #define IFI_CANFD_FILTER_MASK_EXT               BIT(29)
 202 #define IFI_CANFD_FILTER_MASK_EDL               BIT(30)
 203 #define IFI_CANFD_FILTER_MASK_VALID             ((u32)BIT(31))
 204
 205 #define IFI_CANFD_FILTER_IDENT(n)               (0x800 + ((n) * 8) + 4)
 206 #define IFI_CANFD_FILTER_IDENT_IDE              BIT(29)
 207 #define IFI_CANFD_FILTER_IDENT_CANFD            BIT(30)
 208 #define IFI_CANFD_FILTER_IDENT_VALID            ((u32)BIT(31))
 209
 210 /* IFI CANFD private data structure */
 211 struct ifi_canfd_priv {
 212         struct can_priv         can;    /* must be the first member */
 213         struct napi_struct      napi;
 214         struct net_device       *ndev;
 215         void __iomem            *base;
 216 };
 217
 218 static void ifi_canfd_irq_enable(struct net_device *ndev, bool enable)
 219 {
 220         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 221         u32 enirq = 0;
 222
 223         if (enable) {
 224                 enirq = IFI_CANFD_IRQMASK_TXFIFO_EMPTY |
 225                         IFI_CANFD_IRQMASK_RXFIFO_NEMPTY;
 226                 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
 227                         enirq |= IFI_CANFD_INTERRUPT_ERROR_COUNTER;
 228         }
 229
 230         writel(IFI_CANFD_IRQMASK_SET_ERR |
 231                IFI_CANFD_IRQMASK_SET_TS |
 232                IFI_CANFD_IRQMASK_SET_TX |
 233                IFI_CANFD_IRQMASK_SET_RX | enirq,
 234                priv->base + IFI_CANFD_IRQMASK);
 235 }
 236
 237 static void ifi_canfd_read_fifo(struct net_device *ndev)
 238 {
 239         struct net_device_stats *stats = &ndev->stats;
 240         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 241         struct canfd_frame *cf;
 242         struct sk_buff *skb;
 243         const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |
 244                                 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER;
 245         u32 rxdlc, rxid;
 246         u32 dlc, id;
 247         int i;
 248
 249         rxdlc = readl(priv->base + IFI_CANFD_RXFIFO_DLC);
 250         if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)
 251                 skb = alloc_canfd_skb(ndev, &cf);
 252         else
 253                 skb = alloc_can_skb(ndev, (struct can_frame **)&cf);
 254
 255         if (!skb) {
 256                 stats->rx_dropped++;
 257                 return;
 258         }
 259
 260         dlc = (rxdlc >> IFI_CANFD_RXFIFO_DLC_DLC_OFFSET) &
 261               IFI_CANFD_RXFIFO_DLC_DLC_MASK;
 262         if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)
 263                 cf->len = can_dlc2len(dlc);
 264         else
 265                 cf->len = get_can_dlc(dlc);
 266
 267         rxid = readl(priv->base + IFI_CANFD_RXFIFO_ID);
 268         id = (rxid >> IFI_CANFD_RXFIFO_ID_ID_OFFSET);
 269         if (id & IFI_CANFD_RXFIFO_ID_IDE) {
 270                 id &= IFI_CANFD_RXFIFO_ID_ID_XTD_MASK;
 271                 /*
 272                  * In case the Extended ID frame is received, the standard
 273                  * and extended part of the ID are swapped in the register,
 274                  * so swap them back to obtain the correct ID.
 275                  */
 276                 id = (id >> IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET) |
 277                      ((id & IFI_CANFD_RXFIFO_ID_ID_STD_MASK) <<
 278                        IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH);
 279                 id |= CAN_EFF_FLAG;
 280         } else {
 281                 id &= IFI_CANFD_RXFIFO_ID_ID_STD_MASK;
 282         }
 283         cf->can_id = id;
 284
 285         if (rxdlc & IFI_CANFD_RXFIFO_DLC_ESI) {
 286                 cf->flags |= CANFD_ESI;
 287                 netdev_dbg(ndev, "ESI Error\n");
 288         }
 289
 290         if (!(rxdlc & IFI_CANFD_RXFIFO_DLC_EDL) &&
 291             (rxdlc & IFI_CANFD_RXFIFO_DLC_RTR)) {
 292                 cf->can_id |= CAN_RTR_FLAG;
 293         } else {
 294                 if (rxdlc & IFI_CANFD_RXFIFO_DLC_BRS)
 295                         cf->flags |= CANFD_BRS;
 296
 297                 for (i = 0; i < cf->len; i += 4) {
 298                         *(u32 *)(cf->data + i) =
 299                                 readl(priv->base + IFI_CANFD_RXFIFO_DATA + i);
 300                 }
 301         }
 302
 303         /* Remove the packet from FIFO */
 304         writel(IFI_CANFD_RXSTCMD_REMOVE_MSG, priv->base + IFI_CANFD_RXSTCMD);
 305         writel(rx_irq_mask, priv->base + IFI_CANFD_INTERRUPT);
 306
 307         stats->rx_packets++;
 308         stats->rx_bytes += cf->len;
 309
 310         netif_receive_skb(skb);
 311 }
 312
 313 static int ifi_canfd_do_rx_poll(struct net_device *ndev, int quota)
 314 {
 315         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 316         u32 pkts = 0;
 317         u32 rxst;
 318
 319         rxst = readl(priv->base + IFI_CANFD_RXSTCMD);
 320         if (rxst & IFI_CANFD_RXSTCMD_EMPTY) {
 321                 netdev_dbg(ndev, "No messages in RX FIFO\n");
 322                 return 0;
 323         }
 324
 325         for (;;) {
 326                 if (rxst & IFI_CANFD_RXSTCMD_EMPTY)
 327                         break;
 328                 if (quota <= 0)
 329                         break;
 330
 331                 ifi_canfd_read_fifo(ndev);
 332                 quota--;
 333                 pkts++;
 334                 rxst = readl(priv->base + IFI_CANFD_RXSTCMD);
 335         }
 336
 337         if (pkts)
 338                 can_led_event(ndev, CAN_LED_EVENT_RX);
 339
 340         return pkts;
 341 }
 342
 343 static int ifi_canfd_handle_lost_msg(struct net_device *ndev)
 344 {
 345         struct net_device_stats *stats = &ndev->stats;
 346         struct sk_buff *skb;
 347         struct can_frame *frame;
 348
 349         netdev_err(ndev, "RX FIFO overflow, message(s) lost.\n");
 350
 351         stats->rx_errors++;
 352         stats->rx_over_errors++;
 353
 354         skb = alloc_can_err_skb(ndev, &frame);
 355         if (unlikely(!skb))
 356                 return 0;
 357
 358         frame->can_id |= CAN_ERR_CRTL;
 359         frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 360
 361         netif_receive_skb(skb);
 362
 363         return 1;
 364 }
 365
 366 static int ifi_canfd_handle_lec_err(struct net_device *ndev, const u32 errctr)
 367 {
 368         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 369         struct net_device_stats *stats = &ndev->stats;
 370         struct can_frame *cf;
 371         struct sk_buff *skb;
 372         const u32 errmask = IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST |
 373                             IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST |
 374                             IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST |
 375                             IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST |
 376                             IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST |
 377                             IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST |
 378                             IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST;
 379
 380         if (!(errctr & errmask))        /* No error happened. */
 381                 return 0;
 382
 383         priv->can.can_stats.bus_error++;
 384         stats->rx_errors++;
 385
 386         /* Propagate the error condition to the CAN stack. */
 387         skb = alloc_can_err_skb(ndev, &cf);
 388         if (unlikely(!skb))
 389                 return 0;
 390
 391         /* Read the error counter register and check for new errors. */
 392         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 393
 394         if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST)
 395                 cf->data[2] |= CAN_ERR_PROT_OVERLOAD;
 396
 397         if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST)
 398                 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
 399
 400         if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST)
 401                 cf->data[2] |= CAN_ERR_PROT_BIT0;
 402
 403         if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST)
 404                 cf->data[2] |= CAN_ERR_PROT_BIT1;
 405
 406         if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST)
 407                 cf->data[2] |= CAN_ERR_PROT_STUFF;
 408
 409         if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST)
 410                 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
 411
 412         if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST)
 413                 cf->data[2] |= CAN_ERR_PROT_FORM;
 414
 415         /* Reset the error counter, ack the IRQ and re-enable the counter. */
 416         writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);
 417         writel(IFI_CANFD_INTERRUPT_ERROR_COUNTER,
 418                priv->base + IFI_CANFD_INTERRUPT);
 419         writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR);
 420
 421         stats->rx_packets++;
 422         stats->rx_bytes += cf->can_dlc;
 423         netif_receive_skb(skb);
 424
 425         return 1;
 426 }
 427
 428 static int ifi_canfd_get_berr_counter(const struct net_device *ndev,
 429                                       struct can_berr_counter *bec)
 430 {
 431         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 432         u32 err;
 433
 434         err = readl(priv->base + IFI_CANFD_ERROR);
 435         bec->rxerr = (err >> IFI_CANFD_ERROR_RX_OFFSET) &
 436                      IFI_CANFD_ERROR_RX_MASK;
 437         bec->txerr = (err >> IFI_CANFD_ERROR_TX_OFFSET) &
 438                      IFI_CANFD_ERROR_TX_MASK;
 439
 440         return 0;
 441 }
 442
 443 static int ifi_canfd_handle_state_change(struct net_device *ndev,
 444                                          enum can_state new_state)
 445 {
 446         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 447         struct net_device_stats *stats = &ndev->stats;
 448         struct can_frame *cf;
 449         struct sk_buff *skb;
 450         struct can_berr_counter bec;
 451
 452         switch (new_state) {
 453         case CAN_STATE_ERROR_ACTIVE:
 454                 /* error warning state */
 455                 priv->can.can_stats.error_warning++;
 456                 priv->can.state = CAN_STATE_ERROR_WARNING;
 457                 break;
 458         case CAN_STATE_ERROR_PASSIVE:
 459                 /* error passive state */
 460                 priv->can.can_stats.error_passive++;
 461                 priv->can.state = CAN_STATE_ERROR_PASSIVE;
 462                 break;
 463         case CAN_STATE_BUS_OFF:
 464                 /* bus-off state */
 465                 priv->can.state = CAN_STATE_BUS_OFF;
 466                 ifi_canfd_irq_enable(ndev, 0);
 467                 priv->can.can_stats.bus_off++;
 468                 can_bus_off(ndev);
 469                 break;
 470         default:
 471                 break;
 472         }
 473
 474         /* propagate the error condition to the CAN stack */
 475         skb = alloc_can_err_skb(ndev, &cf);
 476         if (unlikely(!skb))
 477                 return 0;
 478
 479         ifi_canfd_get_berr_counter(ndev, &bec);
 480
 481         switch (new_state) {
 482         case CAN_STATE_ERROR_ACTIVE:
 483                 /* error warning state */
 484                 cf->can_id |= CAN_ERR_CRTL;
 485                 cf->data[1] = (bec.txerr > bec.rxerr) ?
 486                         CAN_ERR_CRTL_TX_WARNING :
 487                         CAN_ERR_CRTL_RX_WARNING;
 488                 cf->data[6] = bec.txerr;
 489                 cf->data[7] = bec.rxerr;
 490                 break;
 491         case CAN_STATE_ERROR_PASSIVE:
 492                 /* error passive state */
 493                 cf->can_id |= CAN_ERR_CRTL;
 494                 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
 495                 if (bec.txerr > 127)
 496                         cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
 497                 cf->data[6] = bec.txerr;
 498                 cf->data[7] = bec.rxerr;
 499                 break;
 500         case CAN_STATE_BUS_OFF:
 501                 /* bus-off state */
 502                 cf->can_id |= CAN_ERR_BUSOFF;
 503                 break;
 504         default:
 505                 break;
 506         }
 507
 508         stats->rx_packets++;
 509         stats->rx_bytes += cf->can_dlc;
 510         netif_receive_skb(skb);
 511
 512         return 1;
 513 }
 514
 515 static int ifi_canfd_handle_state_errors(struct net_device *ndev, u32 stcmd)
 516 {
 517         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 518         int work_done = 0;
 519         u32 isr;
 520
 521         /*
 522          * The ErrWarn condition is a little special, since the bit is
 523          * located in the INTERRUPT register instead of STCMD register.
 524          */
 525         isr = readl(priv->base + IFI_CANFD_INTERRUPT);
 526         if ((isr & IFI_CANFD_INTERRUPT_ERROR_WARNING) &&
 527             (priv->can.state != CAN_STATE_ERROR_WARNING)) {
 528                 /* Clear the interrupt */
 529                 writel(IFI_CANFD_INTERRUPT_ERROR_WARNING,
 530                        priv->base + IFI_CANFD_INTERRUPT);
 531                 netdev_dbg(ndev, "Error, entered warning state\n");
 532                 work_done += ifi_canfd_handle_state_change(ndev,
 533                                                 CAN_STATE_ERROR_WARNING);
 534         }
 535
 536         if ((stcmd & IFI_CANFD_STCMD_ERROR_PASSIVE) &&
 537             (priv->can.state != CAN_STATE_ERROR_PASSIVE)) {
 538                 netdev_dbg(ndev, "Error, entered passive state\n");
 539                 work_done += ifi_canfd_handle_state_change(ndev,
 540                                                 CAN_STATE_ERROR_PASSIVE);
 541         }
 542
 543         if ((stcmd & IFI_CANFD_STCMD_BUSOFF) &&
 544             (priv->can.state != CAN_STATE_BUS_OFF)) {
 545                 netdev_dbg(ndev, "Error, entered bus-off state\n");
 546                 work_done += ifi_canfd_handle_state_change(ndev,
 547                                                 CAN_STATE_BUS_OFF);
 548         }
 549
 550         return work_done;
 551 }
 552
 553 static int ifi_canfd_poll(struct napi_struct *napi, int quota)
 554 {
 555         struct net_device *ndev = napi->dev;
 556         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 557         const u32 stcmd_state_mask = IFI_CANFD_STCMD_ERROR_PASSIVE |
 558                                      IFI_CANFD_STCMD_BUSOFF;
 559         int work_done = 0;
 560
 561         u32 stcmd = readl(priv->base + IFI_CANFD_STCMD);
 562         u32 rxstcmd = readl(priv->base + IFI_CANFD_RXSTCMD);
 563         u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR);
 564
 565         /* Handle bus state changes */
 566         if ((stcmd & stcmd_state_mask) ||
 567             ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) == 0))
 568                 work_done += ifi_canfd_handle_state_errors(ndev, stcmd);
 569
 570         /* Handle lost messages on RX */
 571         if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW)
 572                 work_done += ifi_canfd_handle_lost_msg(ndev);
 573
 574         /* Handle lec errors on the bus */
 575         if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
 576                 work_done += ifi_canfd_handle_lec_err(ndev, errctr);
 577
 578         /* Handle normal messages on RX */
 579         if (!(rxstcmd & IFI_CANFD_RXSTCMD_EMPTY))
 580                 work_done += ifi_canfd_do_rx_poll(ndev, quota - work_done);
 581
 582         if (work_done < quota) {
 583                 napi_complete_done(napi, work_done);
 584                 ifi_canfd_irq_enable(ndev, 1);
 585         }
 586
 587         return work_done;
 588 }
 589
 590 static irqreturn_t ifi_canfd_isr(int irq, void *dev_id)
 591 {
 592         struct net_device *ndev = (struct net_device *)dev_id;
 593         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 594         struct net_device_stats *stats = &ndev->stats;
 595         const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |
 596                                 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER |
 597                                 IFI_CANFD_INTERRUPT_ERROR_WARNING |
 598                                 IFI_CANFD_INTERRUPT_ERROR_COUNTER;
 599         const u32 tx_irq_mask = IFI_CANFD_INTERRUPT_TXFIFO_EMPTY |
 600                                 IFI_CANFD_INTERRUPT_TXFIFO_REMOVE;
 601         const u32 clr_irq_mask = ~((u32)(IFI_CANFD_INTERRUPT_SET_IRQ |
 602                                          IFI_CANFD_INTERRUPT_ERROR_WARNING));
 603         u32 isr;
 604
 605         isr = readl(priv->base + IFI_CANFD_INTERRUPT);
 606
 607         /* No interrupt */
 608         if (isr == 0)
 609                 return IRQ_NONE;
 610
 611         /* Clear all pending interrupts but ErrWarn */
 612         writel(clr_irq_mask, priv->base + IFI_CANFD_INTERRUPT);
 613
 614         /* RX IRQ or bus warning, start NAPI */
 615         if (isr & rx_irq_mask) {
 616                 ifi_canfd_irq_enable(ndev, 0);
 617                 napi_schedule(&priv->napi);
 618         }
 619
 620         /* TX IRQ */
 621         if (isr & IFI_CANFD_INTERRUPT_TXFIFO_REMOVE) {
 622                 stats->tx_bytes += can_get_echo_skb(ndev, 0);
 623                 stats->tx_packets++;
 624                 can_led_event(ndev, CAN_LED_EVENT_TX);
 625         }
 626
 627         if (isr & tx_irq_mask)
 628                 netif_wake_queue(ndev);
 629
 630         return IRQ_HANDLED;
 631 }
 632
 633 static const struct can_bittiming_const ifi_canfd_bittiming_const = {
 634         .name           = KBUILD_MODNAME,
 635         .tseg1_min      = 1,    /* Time segment 1 = prop_seg + phase_seg1 */
 636         .tseg1_max      = 256,
 637         .tseg2_min      = 2,    /* Time segment 2 = phase_seg2 */
 638         .tseg2_max      = 256,
 639         .sjw_max        = 128,
 640         .brp_min        = 2,
 641         .brp_max        = 512,
 642         .brp_inc        = 1,
 643 };
 644
 645 static void ifi_canfd_set_bittiming(struct net_device *ndev)
 646 {
 647         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 648         const struct can_bittiming *bt = &priv->can.bittiming;
 649         const struct can_bittiming *dbt = &priv->can.data_bittiming;
 650         u16 brp, sjw, tseg1, tseg2, tdc;
 651
 652         /* Configure bit timing */
 653         brp = bt->brp - 2;
 654         sjw = bt->sjw - 1;
 655         tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
 656         tseg2 = bt->phase_seg2 - 2;
 657         writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |
 658                (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |
 659                (brp << IFI_CANFD_TIME_PRESCALE_OFF) |
 660                (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8),
 661                priv->base + IFI_CANFD_TIME);
 662
 663         /* Configure data bit timing */
 664         brp = dbt->brp - 2;
 665         sjw = dbt->sjw - 1;
 666         tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
 667         tseg2 = dbt->phase_seg2 - 2;
 668         writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |
 669                (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |
 670                (brp << IFI_CANFD_TIME_PRESCALE_OFF) |
 671                (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8),
 672                priv->base + IFI_CANFD_FTIME);
 673
 674         /* Configure transmitter delay */
 675         tdc = dbt->brp * (dbt->prop_seg + dbt->phase_seg1);
 676         tdc &= IFI_CANFD_TDELAY_MASK;
 677         writel(IFI_CANFD_TDELAY_EN | tdc, priv->base + IFI_CANFD_TDELAY);
 678 }
 679
 680 static void ifi_canfd_set_filter(struct net_device *ndev, const u32 id,
 681                                  const u32 mask, const u32 ident)
 682 {
 683         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 684
 685         writel(mask, priv->base + IFI_CANFD_FILTER_MASK(id));
 686         writel(ident, priv->base + IFI_CANFD_FILTER_IDENT(id));
 687 }
 688
 689 static void ifi_canfd_set_filters(struct net_device *ndev)
 690 {
 691         /* Receive all CAN frames (standard ID) */
 692         ifi_canfd_set_filter(ndev, 0,
 693                              IFI_CANFD_FILTER_MASK_VALID |
 694                              IFI_CANFD_FILTER_MASK_EXT,
 695                              IFI_CANFD_FILTER_IDENT_VALID);
 696
 697         /* Receive all CAN frames (extended ID) */
 698         ifi_canfd_set_filter(ndev, 1,
 699                              IFI_CANFD_FILTER_MASK_VALID |
 700                              IFI_CANFD_FILTER_MASK_EXT,
 701                              IFI_CANFD_FILTER_IDENT_VALID |
 702                              IFI_CANFD_FILTER_IDENT_IDE);
 703
 704         /* Receive all CANFD frames */
 705         ifi_canfd_set_filter(ndev, 2,
 706                              IFI_CANFD_FILTER_MASK_VALID |
 707                              IFI_CANFD_FILTER_MASK_EDL |
 708                              IFI_CANFD_FILTER_MASK_EXT,
 709                              IFI_CANFD_FILTER_IDENT_VALID |
 710                              IFI_CANFD_FILTER_IDENT_CANFD |
 711                              IFI_CANFD_FILTER_IDENT_IDE);
 712 }
 713
 714 static void ifi_canfd_start(struct net_device *ndev)
 715 {
 716         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 717         u32 stcmd;
 718
 719         /* Reset the IP */
 720         writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
 721         writel(IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING,
 722                priv->base + IFI_CANFD_STCMD);
 723
 724         ifi_canfd_set_bittiming(ndev);
 725         ifi_canfd_set_filters(ndev);
 726
 727         /* Reset FIFOs */
 728         writel(IFI_CANFD_RXSTCMD_RESET, priv->base + IFI_CANFD_RXSTCMD);
 729         writel(0, priv->base + IFI_CANFD_RXSTCMD);
 730         writel(IFI_CANFD_TXSTCMD_RESET, priv->base + IFI_CANFD_TXSTCMD);
 731         writel(0, priv->base + IFI_CANFD_TXSTCMD);
 732
 733         /* Repeat transmission until successful */
 734         writel(0, priv->base + IFI_CANFD_REPEAT);
 735         writel(0, priv->base + IFI_CANFD_SUSPEND);
 736
 737         /* Clear all pending interrupts */
 738         writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
 739                priv->base + IFI_CANFD_INTERRUPT);
 740
 741         stcmd = IFI_CANFD_STCMD_ENABLE | IFI_CANFD_STCMD_NORMAL_MODE |
 742                 IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING;
 743
 744         if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 745                 stcmd |= IFI_CANFD_STCMD_BUSMONITOR;
 746
 747         if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
 748                 stcmd |= IFI_CANFD_STCMD_LOOPBACK;
 749
 750         if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) &&
 751             !(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO))
 752                 stcmd |= IFI_CANFD_STCMD_ENABLE_ISO;
 753
 754         if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))
 755                 stcmd |= IFI_CANFD_STCMD_DISABLE_CANFD;
 756
 757         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 758
 759         ifi_canfd_irq_enable(ndev, 1);
 760
 761         /* Unlock, reset and enable the error counter. */
 762         writel(IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC,
 763                priv->base + IFI_CANFD_ERROR_CTR);
 764         writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);
 765         writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR);
 766
 767         /* Enable controller */
 768         writel(stcmd, priv->base + IFI_CANFD_STCMD);
 769 }
 770
 771 static void ifi_canfd_stop(struct net_device *ndev)
 772 {
 773         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 774
 775         /* Reset and disable the error counter. */
 776         writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);
 777         writel(0, priv->base + IFI_CANFD_ERROR_CTR);
 778
 779         /* Reset the IP */
 780         writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
 781
 782         /* Mask all interrupts */
 783         writel(~0, priv->base + IFI_CANFD_IRQMASK);
 784
 785         /* Clear all pending interrupts */
 786         writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
 787                priv->base + IFI_CANFD_INTERRUPT);
 788
 789         /* Set the state as STOPPED */
 790         priv->can.state = CAN_STATE_STOPPED;
 791 }
 792
 793 static int ifi_canfd_set_mode(struct net_device *ndev, enum can_mode mode)
 794 {
 795         switch (mode) {
 796         case CAN_MODE_START:
 797                 ifi_canfd_start(ndev);
 798                 netif_wake_queue(ndev);
 799                 break;
 800         default:
 801                 return -EOPNOTSUPP;
 802         }
 803
 804         return 0;
 805 }
 806
 807 static int ifi_canfd_open(struct net_device *ndev)
 808 {
 809         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 810         int ret;
 811
 812         ret = open_candev(ndev);
 813         if (ret) {
 814                 netdev_err(ndev, "Failed to open CAN device\n");
 815                 return ret;
 816         }
 817
 818         /* Register interrupt handler */
 819         ret = request_irq(ndev->irq, ifi_canfd_isr, IRQF_SHARED,
 820                           ndev->name, ndev);
 821         if (ret < 0) {
 822                 netdev_err(ndev, "Failed to request interrupt\n");
 823                 goto err_irq;
 824         }
 825
 826         ifi_canfd_start(ndev);
 827
 828         can_led_event(ndev, CAN_LED_EVENT_OPEN);
 829         napi_enable(&priv->napi);
 830         netif_start_queue(ndev);
 831
 832         return 0;
 833 err_irq:
 834         close_candev(ndev);
 835         return ret;
 836 }
 837
 838 static int ifi_canfd_close(struct net_device *ndev)
 839 {
 840         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 841
 842         netif_stop_queue(ndev);
 843         napi_disable(&priv->napi);
 844
 845         ifi_canfd_stop(ndev);
 846
 847         free_irq(ndev->irq, ndev);
 848
 849         close_candev(ndev);
 850
 851         can_led_event(ndev, CAN_LED_EVENT_STOP);
 852
 853         return 0;
 854 }
 855
 856 static netdev_tx_t ifi_canfd_start_xmit(struct sk_buff *skb,
 857                                         struct net_device *ndev)
 858 {
 859         struct ifi_canfd_priv *priv = netdev_priv(ndev);
 860         struct canfd_frame *cf = (struct canfd_frame *)skb->data;
 861         u32 txst, txid, txdlc;
 862         int i;
 863
 864         if (can_dropped_invalid_skb(ndev, skb))
 865                 return NETDEV_TX_OK;
 866
 867         /* Check if the TX buffer is full */
 868         txst = readl(priv->base + IFI_CANFD_TXSTCMD);
 869         if (txst & IFI_CANFD_TXSTCMD_FULL) {
 870                 netif_stop_queue(ndev);
 871                 netdev_err(ndev, "BUG! TX FIFO full when queue awake!\n");
 872                 return NETDEV_TX_BUSY;
 873         }
 874
 875         netif_stop_queue(ndev);
 876
 877         if (cf->can_id & CAN_EFF_FLAG) {
 878                 txid = cf->can_id & CAN_EFF_MASK;
 879                 /*
 880                  * In case the Extended ID frame is transmitted, the
 881                  * standard and extended part of the ID are swapped
 882                  * in the register, so swap them back to send the
 883                  * correct ID.
 884                  */
 885                 txid = (txid >> IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH) |
 886                        ((txid & IFI_CANFD_TXFIFO_ID_ID_XTD_MASK) <<
 887                          IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET);
 888                 txid |= IFI_CANFD_TXFIFO_ID_IDE;
 889         } else {
 890                 txid = cf->can_id & CAN_SFF_MASK;
 891         }
 892
 893         txdlc = can_len2dlc(cf->len);
 894         if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) {
 895                 txdlc |= IFI_CANFD_TXFIFO_DLC_EDL;
 896                 if (cf->flags & CANFD_BRS)
 897                         txdlc |= IFI_CANFD_TXFIFO_DLC_BRS;
 898         }
 899
 900         if (cf->can_id & CAN_RTR_FLAG)
 901                 txdlc |= IFI_CANFD_TXFIFO_DLC_RTR;
 902
 903         /* message ram configuration */
 904         writel(txid, priv->base + IFI_CANFD_TXFIFO_ID);
 905         writel(txdlc, priv->base + IFI_CANFD_TXFIFO_DLC);
 906
 907         for (i = 0; i < cf->len; i += 4) {
 908                 writel(*(u32 *)(cf->data + i),
 909                        priv->base + IFI_CANFD_TXFIFO_DATA + i);
 910         }
 911
 912         writel(0, priv->base + IFI_CANFD_TXFIFO_REPEATCOUNT);
 913         writel(0, priv->base + IFI_CANFD_TXFIFO_SUSPEND_US);
 914
 915         can_put_echo_skb(skb, ndev, 0);
 916
 917         /* Start the transmission */
 918         writel(IFI_CANFD_TXSTCMD_ADD_MSG, priv->base + IFI_CANFD_TXSTCMD);
 919
 920         return NETDEV_TX_OK;
 921 }
 922
 923 static const struct net_device_ops ifi_canfd_netdev_ops = {
 924         .ndo_open       = ifi_canfd_open,
 925         .ndo_stop       = ifi_canfd_close,
 926         .ndo_start_xmit = ifi_canfd_start_xmit,
 927         .ndo_change_mtu = can_change_mtu,
 928 };
 929
 930 static int ifi_canfd_plat_probe(struct platform_device *pdev)
 931 {
 932         struct device *dev = &pdev->dev;
 933         struct net_device *ndev;
 934         struct ifi_canfd_priv *priv;
 935         struct resource *res;
 936         void __iomem *addr;
 937         int irq, ret;
 938         u32 id, rev;
 939
 940         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 941         addr = devm_ioremap_resource(dev, res);
 942         irq = platform_get_irq(pdev, 0);
 943         if (IS_ERR(addr) || irq < 0)
 944                 return -EINVAL;
 945
 946         id = readl(addr + IFI_CANFD_IP_ID);
 947         if (id != IFI_CANFD_IP_ID_VALUE) {
 948                 dev_err(dev, "This block is not IFI CANFD, id=%08x\n", id);
 949                 return -EINVAL;
 950         }
 951
 952         rev = readl(addr + IFI_CANFD_VER) & IFI_CANFD_VER_REV_MASK;
 953         if (rev < IFI_CANFD_VER_REV_MIN_SUPPORTED) {
 954                 dev_err(dev, "This block is too old (rev %i), minimum supported is rev %i\n",
 955                         rev, IFI_CANFD_VER_REV_MIN_SUPPORTED);
 956                 return -EINVAL;
 957         }
 958
 959         ndev = alloc_candev(sizeof(*priv), 1);
 960         if (!ndev)
 961                 return -ENOMEM;
 962
 963         ndev->irq = irq;
 964         ndev->flags |= IFF_ECHO;        /* we support local echo */
 965         ndev->netdev_ops = &ifi_canfd_netdev_ops;
 966
 967         priv = netdev_priv(ndev);
 968         priv->ndev = ndev;
 969         priv->base = addr;
 970
 971         netif_napi_add(ndev, &priv->napi, ifi_canfd_poll, 64);
 972
 973         priv->can.state = CAN_STATE_STOPPED;
 974
 975         priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK);
 976
 977         priv->can.bittiming_const       = &ifi_canfd_bittiming_const;
 978         priv->can.data_bittiming_const  = &ifi_canfd_bittiming_const;
 979         priv->can.do_set_mode           = ifi_canfd_set_mode;
 980         priv->can.do_get_berr_counter   = ifi_canfd_get_berr_counter;
 981
 982         /* IFI CANFD can do both Bosch FD and ISO FD */
 983         priv->can.ctrlmode = CAN_CTRLMODE_FD;
 984
 985         /* IFI CANFD can do both Bosch FD and ISO FD */
 986         priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
 987                                        CAN_CTRLMODE_LISTENONLY |
 988                                        CAN_CTRLMODE_FD |
 989                                        CAN_CTRLMODE_FD_NON_ISO |
 990                                        CAN_CTRLMODE_BERR_REPORTING;
 991
 992         platform_set_drvdata(pdev, ndev);
 993         SET_NETDEV_DEV(ndev, dev);
 994
 995         ret = register_candev(ndev);
 996         if (ret) {
 997                 dev_err(dev, "Failed to register (ret=%d)\n", ret);
 998                 goto err_reg;
 999         }
1000
1001         devm_can_led_init(ndev);
1002
1003         dev_info(dev, "Driver registered: regs=%p, irq=%d, clock=%d\n",
1004                  priv->base, ndev->irq, priv->can.clock.freq);
1005
1006         return 0;
1007
1008 err_reg:
1009         free_candev(ndev);
1010         return ret;
1011 }
1012
1013 static int ifi_canfd_plat_remove(struct platform_device *pdev)
1014 {
1015         struct net_device *ndev = platform_get_drvdata(pdev);
1016
1017         unregister_candev(ndev);
1018         platform_set_drvdata(pdev, NULL);
1019         free_candev(ndev);
1020
1021         return 0;
1022 }
1023
1024 static const struct of_device_id ifi_canfd_of_table[] = {
1025         { .compatible = "ifi,canfd-1.0", .data = NULL },
1026         { /* sentinel */ },
1027 };
1028 MODULE_DEVICE_TABLE(of, ifi_canfd_of_table);
1029
1030 static struct platform_driver ifi_canfd_plat_driver = {
1031         .driver = {
1032                 .name           = KBUILD_MODNAME,
1033                 .of_match_table = ifi_canfd_of_table,
1034         },
1035         .probe  = ifi_canfd_plat_probe,
1036         .remove = ifi_canfd_plat_remove,
1037 };
1038
1039 module_platform_driver(ifi_canfd_plat_driver);
1040
1041 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
1042 MODULE_LICENSE("GPL v2");
1043 MODULE_DESCRIPTION("CAN bus driver for IFI CANFD controller");