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