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