Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * CAN bus driver for IFI CANFD controller
0003  *
0004  * Copyright (C) 2016 Marek Vasut <marex@denx.de>
0005  *
0006  * Details about this controller can be found at
0007  * http://www.ifi-pld.de/IP/CANFD/canfd.html
0008  *
0009  * This file is licensed under the terms of the GNU General Public
0010  * License version 2. This program is licensed "as is" without any
0011  * warranty of any kind, whether express or implied.
0012  */
0013 
0014 #include <linux/clk.h>
0015 #include <linux/delay.h>
0016 #include <linux/ethtool.h>
0017 #include <linux/interrupt.h>
0018 #include <linux/io.h>
0019 #include <linux/kernel.h>
0020 #include <linux/module.h>
0021 #include <linux/netdevice.h>
0022 #include <linux/of.h>
0023 #include <linux/of_device.h>
0024 #include <linux/platform_device.h>
0025 
0026 #include <linux/can/dev.h>
0027 
0028 #define IFI_CANFD_STCMD             0x0
0029 #define IFI_CANFD_STCMD_HARDRESET       0xDEADCAFD
0030 #define IFI_CANFD_STCMD_ENABLE          BIT(0)
0031 #define IFI_CANFD_STCMD_ERROR_ACTIVE        BIT(2)
0032 #define IFI_CANFD_STCMD_ERROR_PASSIVE       BIT(3)
0033 #define IFI_CANFD_STCMD_BUSOFF          BIT(4)
0034 #define IFI_CANFD_STCMD_ERROR_WARNING       BIT(5)
0035 #define IFI_CANFD_STCMD_BUSMONITOR      BIT(16)
0036 #define IFI_CANFD_STCMD_LOOPBACK        BIT(18)
0037 #define IFI_CANFD_STCMD_DISABLE_CANFD       BIT(24)
0038 #define IFI_CANFD_STCMD_ENABLE_ISO      BIT(25)
0039 #define IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING   BIT(26)
0040 #define IFI_CANFD_STCMD_NORMAL_MODE     ((u32)BIT(31))
0041 
0042 #define IFI_CANFD_RXSTCMD           0x4
0043 #define IFI_CANFD_RXSTCMD_REMOVE_MSG        BIT(0)
0044 #define IFI_CANFD_RXSTCMD_RESET         BIT(7)
0045 #define IFI_CANFD_RXSTCMD_EMPTY         BIT(8)
0046 #define IFI_CANFD_RXSTCMD_OVERFLOW      BIT(13)
0047 
0048 #define IFI_CANFD_TXSTCMD           0x8
0049 #define IFI_CANFD_TXSTCMD_ADD_MSG       BIT(0)
0050 #define IFI_CANFD_TXSTCMD_HIGH_PRIO     BIT(1)
0051 #define IFI_CANFD_TXSTCMD_RESET         BIT(7)
0052 #define IFI_CANFD_TXSTCMD_EMPTY         BIT(8)
0053 #define IFI_CANFD_TXSTCMD_FULL          BIT(12)
0054 #define IFI_CANFD_TXSTCMD_OVERFLOW      BIT(13)
0055 
0056 #define IFI_CANFD_INTERRUPT         0xc
0057 #define IFI_CANFD_INTERRUPT_ERROR_BUSOFF    BIT(0)
0058 #define IFI_CANFD_INTERRUPT_ERROR_WARNING   BIT(1)
0059 #define IFI_CANFD_INTERRUPT_ERROR_STATE_CHG BIT(2)
0060 #define IFI_CANFD_INTERRUPT_ERROR_REC_TEC_INC   BIT(3)
0061 #define IFI_CANFD_INTERRUPT_ERROR_COUNTER   BIT(10)
0062 #define IFI_CANFD_INTERRUPT_TXFIFO_EMPTY    BIT(16)
0063 #define IFI_CANFD_INTERRUPT_TXFIFO_REMOVE   BIT(22)
0064 #define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY   BIT(24)
0065 #define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER   BIT(25)
0066 #define IFI_CANFD_INTERRUPT_SET_IRQ     ((u32)BIT(31))
0067 
0068 #define IFI_CANFD_IRQMASK           0x10
0069 #define IFI_CANFD_IRQMASK_ERROR_BUSOFF      BIT(0)
0070 #define IFI_CANFD_IRQMASK_ERROR_WARNING     BIT(1)
0071 #define IFI_CANFD_IRQMASK_ERROR_STATE_CHG   BIT(2)
0072 #define IFI_CANFD_IRQMASK_ERROR_REC_TEC_INC BIT(3)
0073 #define IFI_CANFD_IRQMASK_SET_ERR       BIT(7)
0074 #define IFI_CANFD_IRQMASK_SET_TS        BIT(15)
0075 #define IFI_CANFD_IRQMASK_TXFIFO_EMPTY      BIT(16)
0076 #define IFI_CANFD_IRQMASK_SET_TX        BIT(23)
0077 #define IFI_CANFD_IRQMASK_RXFIFO_NEMPTY     BIT(24)
0078 #define IFI_CANFD_IRQMASK_SET_RX        ((u32)BIT(31))
0079 
0080 #define IFI_CANFD_TIME              0x14
0081 #define IFI_CANFD_FTIME             0x18
0082 #define IFI_CANFD_TIME_TIMEB_OFF        0
0083 #define IFI_CANFD_TIME_TIMEA_OFF        8
0084 #define IFI_CANFD_TIME_PRESCALE_OFF     16
0085 #define IFI_CANFD_TIME_SJW_OFF_7_9_8_8      25
0086 #define IFI_CANFD_TIME_SJW_OFF_4_12_6_6     28
0087 #define IFI_CANFD_TIME_SET_SJW_4_12_6_6     BIT(6)
0088 #define IFI_CANFD_TIME_SET_TIMEB_4_12_6_6   BIT(7)
0089 #define IFI_CANFD_TIME_SET_PRESC_4_12_6_6   BIT(14)
0090 #define IFI_CANFD_TIME_SET_TIMEA_4_12_6_6   BIT(15)
0091 
0092 #define IFI_CANFD_TDELAY            0x1c
0093 #define IFI_CANFD_TDELAY_DEFAULT        0xb
0094 #define IFI_CANFD_TDELAY_MASK           0x3fff
0095 #define IFI_CANFD_TDELAY_ABS            BIT(14)
0096 #define IFI_CANFD_TDELAY_EN         BIT(15)
0097 
0098 #define IFI_CANFD_ERROR             0x20
0099 #define IFI_CANFD_ERROR_TX_OFFSET       0
0100 #define IFI_CANFD_ERROR_TX_MASK         0xff
0101 #define IFI_CANFD_ERROR_RX_OFFSET       16
0102 #define IFI_CANFD_ERROR_RX_MASK         0xff
0103 
0104 #define IFI_CANFD_ERRCNT            0x24
0105 
0106 #define IFI_CANFD_SUSPEND           0x28
0107 
0108 #define IFI_CANFD_REPEAT            0x2c
0109 
0110 #define IFI_CANFD_TRAFFIC           0x30
0111 
0112 #define IFI_CANFD_TSCONTROL         0x34
0113 
0114 #define IFI_CANFD_TSC               0x38
0115 
0116 #define IFI_CANFD_TST               0x3c
0117 
0118 #define IFI_CANFD_RES1              0x40
0119 
0120 #define IFI_CANFD_ERROR_CTR         0x44
0121 #define IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC    0x21302899
0122 #define IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST  BIT(0)
0123 #define IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST BIT(1)
0124 #define IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST    BIT(2)
0125 #define IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST    BIT(3)
0126 #define IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST   BIT(4)
0127 #define IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST BIT(5)
0128 #define IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST    BIT(6)
0129 #define IFI_CANFD_ERROR_CTR_OVERLOAD_ALL    BIT(8)
0130 #define IFI_CANFD_ERROR_CTR_ACK_ERROR_ALL   BIT(9)
0131 #define IFI_CANFD_ERROR_CTR_BIT0_ERROR_ALL  BIT(10)
0132 #define IFI_CANFD_ERROR_CTR_BIT1_ERROR_ALL  BIT(11)
0133 #define IFI_CANFD_ERROR_CTR_STUFF_ERROR_ALL BIT(12)
0134 #define IFI_CANFD_ERROR_CTR_CRC_ERROR_ALL   BIT(13)
0135 #define IFI_CANFD_ERROR_CTR_FORM_ERROR_ALL  BIT(14)
0136 #define IFI_CANFD_ERROR_CTR_BITPOSITION_OFFSET  16
0137 #define IFI_CANFD_ERROR_CTR_BITPOSITION_MASK    0xff
0138 #define IFI_CANFD_ERROR_CTR_ER_RESET        BIT(30)
0139 #define IFI_CANFD_ERROR_CTR_ER_ENABLE       ((u32)BIT(31))
0140 
0141 #define IFI_CANFD_PAR               0x48
0142 
0143 #define IFI_CANFD_CANCLOCK          0x4c
0144 
0145 #define IFI_CANFD_SYSCLOCK          0x50
0146 
0147 #define IFI_CANFD_VER               0x54
0148 #define IFI_CANFD_VER_REV_MASK          0xff
0149 #define IFI_CANFD_VER_REV_MIN_SUPPORTED     0x15
0150 
0151 #define IFI_CANFD_IP_ID             0x58
0152 #define IFI_CANFD_IP_ID_VALUE           0xD073CAFD
0153 
0154 #define IFI_CANFD_TEST              0x5c
0155 
0156 #define IFI_CANFD_RXFIFO_TS_63_32       0x60
0157 
0158 #define IFI_CANFD_RXFIFO_TS_31_0        0x64
0159 
0160 #define IFI_CANFD_RXFIFO_DLC            0x68
0161 #define IFI_CANFD_RXFIFO_DLC_DLC_OFFSET     0
0162 #define IFI_CANFD_RXFIFO_DLC_DLC_MASK       0xf
0163 #define IFI_CANFD_RXFIFO_DLC_RTR        BIT(4)
0164 #define IFI_CANFD_RXFIFO_DLC_EDL        BIT(5)
0165 #define IFI_CANFD_RXFIFO_DLC_BRS        BIT(6)
0166 #define IFI_CANFD_RXFIFO_DLC_ESI        BIT(7)
0167 #define IFI_CANFD_RXFIFO_DLC_OBJ_OFFSET     8
0168 #define IFI_CANFD_RXFIFO_DLC_OBJ_MASK       0x1ff
0169 #define IFI_CANFD_RXFIFO_DLC_FNR_OFFSET     24
0170 #define IFI_CANFD_RXFIFO_DLC_FNR_MASK       0xff
0171 
0172 #define IFI_CANFD_RXFIFO_ID         0x6c
0173 #define IFI_CANFD_RXFIFO_ID_ID_OFFSET       0
0174 #define IFI_CANFD_RXFIFO_ID_ID_STD_MASK     CAN_SFF_MASK
0175 #define IFI_CANFD_RXFIFO_ID_ID_STD_OFFSET   0
0176 #define IFI_CANFD_RXFIFO_ID_ID_STD_WIDTH    10
0177 #define IFI_CANFD_RXFIFO_ID_ID_XTD_MASK     CAN_EFF_MASK
0178 #define IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET   11
0179 #define IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH    18
0180 #define IFI_CANFD_RXFIFO_ID_IDE         BIT(29)
0181 
0182 #define IFI_CANFD_RXFIFO_DATA           0x70    /* 0x70..0xac */
0183 
0184 #define IFI_CANFD_TXFIFO_SUSPEND_US     0xb0
0185 
0186 #define IFI_CANFD_TXFIFO_REPEATCOUNT        0xb4
0187 
0188 #define IFI_CANFD_TXFIFO_DLC            0xb8
0189 #define IFI_CANFD_TXFIFO_DLC_DLC_OFFSET     0
0190 #define IFI_CANFD_TXFIFO_DLC_DLC_MASK       0xf
0191 #define IFI_CANFD_TXFIFO_DLC_RTR        BIT(4)
0192 #define IFI_CANFD_TXFIFO_DLC_EDL        BIT(5)
0193 #define IFI_CANFD_TXFIFO_DLC_BRS        BIT(6)
0194 #define IFI_CANFD_TXFIFO_DLC_FNR_OFFSET     24
0195 #define IFI_CANFD_TXFIFO_DLC_FNR_MASK       0xff
0196 
0197 #define IFI_CANFD_TXFIFO_ID         0xbc
0198 #define IFI_CANFD_TXFIFO_ID_ID_OFFSET       0
0199 #define IFI_CANFD_TXFIFO_ID_ID_STD_MASK     CAN_SFF_MASK
0200 #define IFI_CANFD_TXFIFO_ID_ID_STD_OFFSET   0
0201 #define IFI_CANFD_TXFIFO_ID_ID_STD_WIDTH    10
0202 #define IFI_CANFD_TXFIFO_ID_ID_XTD_MASK     CAN_EFF_MASK
0203 #define IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET   11
0204 #define IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH    18
0205 #define IFI_CANFD_TXFIFO_ID_IDE         BIT(29)
0206 
0207 #define IFI_CANFD_TXFIFO_DATA           0xc0    /* 0xb0..0xfc */
0208 
0209 #define IFI_CANFD_FILTER_MASK(n)        (0x800 + ((n) * 8) + 0)
0210 #define IFI_CANFD_FILTER_MASK_EXT       BIT(29)
0211 #define IFI_CANFD_FILTER_MASK_EDL       BIT(30)
0212 #define IFI_CANFD_FILTER_MASK_VALID     ((u32)BIT(31))
0213 
0214 #define IFI_CANFD_FILTER_IDENT(n)       (0x800 + ((n) * 8) + 4)
0215 #define IFI_CANFD_FILTER_IDENT_IDE      BIT(29)
0216 #define IFI_CANFD_FILTER_IDENT_CANFD        BIT(30)
0217 #define IFI_CANFD_FILTER_IDENT_VALID        ((u32)BIT(31))
0218 
0219 /* IFI CANFD private data structure */
0220 struct ifi_canfd_priv {
0221     struct can_priv     can;    /* must be the first member */
0222     struct napi_struct  napi;
0223     struct net_device   *ndev;
0224     void __iomem        *base;
0225 };
0226 
0227 static void ifi_canfd_irq_enable(struct net_device *ndev, bool enable)
0228 {
0229     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0230     u32 enirq = 0;
0231 
0232     if (enable) {
0233         enirq = IFI_CANFD_IRQMASK_TXFIFO_EMPTY |
0234             IFI_CANFD_IRQMASK_RXFIFO_NEMPTY |
0235             IFI_CANFD_IRQMASK_ERROR_STATE_CHG |
0236             IFI_CANFD_IRQMASK_ERROR_WARNING |
0237             IFI_CANFD_IRQMASK_ERROR_BUSOFF;
0238         if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
0239             enirq |= IFI_CANFD_INTERRUPT_ERROR_COUNTER;
0240     }
0241 
0242     writel(IFI_CANFD_IRQMASK_SET_ERR |
0243            IFI_CANFD_IRQMASK_SET_TS |
0244            IFI_CANFD_IRQMASK_SET_TX |
0245            IFI_CANFD_IRQMASK_SET_RX | enirq,
0246            priv->base + IFI_CANFD_IRQMASK);
0247 }
0248 
0249 static void ifi_canfd_read_fifo(struct net_device *ndev)
0250 {
0251     struct net_device_stats *stats = &ndev->stats;
0252     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0253     struct canfd_frame *cf;
0254     struct sk_buff *skb;
0255     const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |
0256                 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER;
0257     u32 rxdlc, rxid;
0258     u32 dlc, id;
0259     int i;
0260 
0261     rxdlc = readl(priv->base + IFI_CANFD_RXFIFO_DLC);
0262     if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)
0263         skb = alloc_canfd_skb(ndev, &cf);
0264     else
0265         skb = alloc_can_skb(ndev, (struct can_frame **)&cf);
0266 
0267     if (!skb) {
0268         stats->rx_dropped++;
0269         return;
0270     }
0271 
0272     dlc = (rxdlc >> IFI_CANFD_RXFIFO_DLC_DLC_OFFSET) &
0273           IFI_CANFD_RXFIFO_DLC_DLC_MASK;
0274     if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)
0275         cf->len = can_fd_dlc2len(dlc);
0276     else
0277         cf->len = can_cc_dlc2len(dlc);
0278 
0279     rxid = readl(priv->base + IFI_CANFD_RXFIFO_ID);
0280     id = (rxid >> IFI_CANFD_RXFIFO_ID_ID_OFFSET);
0281     if (id & IFI_CANFD_RXFIFO_ID_IDE) {
0282         id &= IFI_CANFD_RXFIFO_ID_ID_XTD_MASK;
0283         /*
0284          * In case the Extended ID frame is received, the standard
0285          * and extended part of the ID are swapped in the register,
0286          * so swap them back to obtain the correct ID.
0287          */
0288         id = (id >> IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET) |
0289              ((id & IFI_CANFD_RXFIFO_ID_ID_STD_MASK) <<
0290                IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH);
0291         id |= CAN_EFF_FLAG;
0292     } else {
0293         id &= IFI_CANFD_RXFIFO_ID_ID_STD_MASK;
0294     }
0295     cf->can_id = id;
0296 
0297     if (rxdlc & IFI_CANFD_RXFIFO_DLC_ESI) {
0298         cf->flags |= CANFD_ESI;
0299         netdev_dbg(ndev, "ESI Error\n");
0300     }
0301 
0302     if (!(rxdlc & IFI_CANFD_RXFIFO_DLC_EDL) &&
0303         (rxdlc & IFI_CANFD_RXFIFO_DLC_RTR)) {
0304         cf->can_id |= CAN_RTR_FLAG;
0305     } else {
0306         if (rxdlc & IFI_CANFD_RXFIFO_DLC_BRS)
0307             cf->flags |= CANFD_BRS;
0308 
0309         for (i = 0; i < cf->len; i += 4) {
0310             *(u32 *)(cf->data + i) =
0311                 readl(priv->base + IFI_CANFD_RXFIFO_DATA + i);
0312         }
0313 
0314         stats->rx_bytes += cf->len;
0315     }
0316     stats->rx_packets++;
0317 
0318     /* Remove the packet from FIFO */
0319     writel(IFI_CANFD_RXSTCMD_REMOVE_MSG, priv->base + IFI_CANFD_RXSTCMD);
0320     writel(rx_irq_mask, priv->base + IFI_CANFD_INTERRUPT);
0321 
0322     netif_receive_skb(skb);
0323 }
0324 
0325 static int ifi_canfd_do_rx_poll(struct net_device *ndev, int quota)
0326 {
0327     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0328     u32 pkts = 0;
0329     u32 rxst;
0330 
0331     rxst = readl(priv->base + IFI_CANFD_RXSTCMD);
0332     if (rxst & IFI_CANFD_RXSTCMD_EMPTY) {
0333         netdev_dbg(ndev, "No messages in RX FIFO\n");
0334         return 0;
0335     }
0336 
0337     for (;;) {
0338         if (rxst & IFI_CANFD_RXSTCMD_EMPTY)
0339             break;
0340         if (quota <= 0)
0341             break;
0342 
0343         ifi_canfd_read_fifo(ndev);
0344         quota--;
0345         pkts++;
0346         rxst = readl(priv->base + IFI_CANFD_RXSTCMD);
0347     }
0348 
0349     return pkts;
0350 }
0351 
0352 static int ifi_canfd_handle_lost_msg(struct net_device *ndev)
0353 {
0354     struct net_device_stats *stats = &ndev->stats;
0355     struct sk_buff *skb;
0356     struct can_frame *frame;
0357 
0358     netdev_err(ndev, "RX FIFO overflow, message(s) lost.\n");
0359 
0360     stats->rx_errors++;
0361     stats->rx_over_errors++;
0362 
0363     skb = alloc_can_err_skb(ndev, &frame);
0364     if (unlikely(!skb))
0365         return 0;
0366 
0367     frame->can_id |= CAN_ERR_CRTL;
0368     frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
0369 
0370     netif_receive_skb(skb);
0371 
0372     return 1;
0373 }
0374 
0375 static int ifi_canfd_handle_lec_err(struct net_device *ndev)
0376 {
0377     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0378     struct net_device_stats *stats = &ndev->stats;
0379     struct can_frame *cf;
0380     struct sk_buff *skb;
0381     u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR);
0382     const u32 errmask = IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST |
0383                 IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST |
0384                 IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST |
0385                 IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST |
0386                 IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST |
0387                 IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST |
0388                 IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST;
0389 
0390     if (!(errctr & errmask))    /* No error happened. */
0391         return 0;
0392 
0393     priv->can.can_stats.bus_error++;
0394     stats->rx_errors++;
0395 
0396     /* Propagate the error condition to the CAN stack. */
0397     skb = alloc_can_err_skb(ndev, &cf);
0398     if (unlikely(!skb))
0399         return 0;
0400 
0401     /* Read the error counter register and check for new errors. */
0402     cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
0403 
0404     if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST)
0405         cf->data[2] |= CAN_ERR_PROT_OVERLOAD;
0406 
0407     if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST)
0408         cf->data[3] = CAN_ERR_PROT_LOC_ACK;
0409 
0410     if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST)
0411         cf->data[2] |= CAN_ERR_PROT_BIT0;
0412 
0413     if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST)
0414         cf->data[2] |= CAN_ERR_PROT_BIT1;
0415 
0416     if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST)
0417         cf->data[2] |= CAN_ERR_PROT_STUFF;
0418 
0419     if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST)
0420         cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
0421 
0422     if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST)
0423         cf->data[2] |= CAN_ERR_PROT_FORM;
0424 
0425     /* Reset the error counter, ack the IRQ and re-enable the counter. */
0426     writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);
0427     writel(IFI_CANFD_INTERRUPT_ERROR_COUNTER,
0428            priv->base + IFI_CANFD_INTERRUPT);
0429     writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR);
0430 
0431     netif_receive_skb(skb);
0432 
0433     return 1;
0434 }
0435 
0436 static int ifi_canfd_get_berr_counter(const struct net_device *ndev,
0437                       struct can_berr_counter *bec)
0438 {
0439     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0440     u32 err;
0441 
0442     err = readl(priv->base + IFI_CANFD_ERROR);
0443     bec->rxerr = (err >> IFI_CANFD_ERROR_RX_OFFSET) &
0444              IFI_CANFD_ERROR_RX_MASK;
0445     bec->txerr = (err >> IFI_CANFD_ERROR_TX_OFFSET) &
0446              IFI_CANFD_ERROR_TX_MASK;
0447 
0448     return 0;
0449 }
0450 
0451 static int ifi_canfd_handle_state_change(struct net_device *ndev,
0452                      enum can_state new_state)
0453 {
0454     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0455     struct can_frame *cf;
0456     struct sk_buff *skb;
0457     struct can_berr_counter bec;
0458 
0459     switch (new_state) {
0460     case CAN_STATE_ERROR_ACTIVE:
0461         /* error active state */
0462         priv->can.can_stats.error_warning++;
0463         priv->can.state = CAN_STATE_ERROR_ACTIVE;
0464         break;
0465     case CAN_STATE_ERROR_WARNING:
0466         /* error warning state */
0467         priv->can.can_stats.error_warning++;
0468         priv->can.state = CAN_STATE_ERROR_WARNING;
0469         break;
0470     case CAN_STATE_ERROR_PASSIVE:
0471         /* error passive state */
0472         priv->can.can_stats.error_passive++;
0473         priv->can.state = CAN_STATE_ERROR_PASSIVE;
0474         break;
0475     case CAN_STATE_BUS_OFF:
0476         /* bus-off state */
0477         priv->can.state = CAN_STATE_BUS_OFF;
0478         ifi_canfd_irq_enable(ndev, 0);
0479         priv->can.can_stats.bus_off++;
0480         can_bus_off(ndev);
0481         break;
0482     default:
0483         break;
0484     }
0485 
0486     /* propagate the error condition to the CAN stack */
0487     skb = alloc_can_err_skb(ndev, &cf);
0488     if (unlikely(!skb))
0489         return 0;
0490 
0491     ifi_canfd_get_berr_counter(ndev, &bec);
0492 
0493     switch (new_state) {
0494     case CAN_STATE_ERROR_WARNING:
0495         /* error warning state */
0496         cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;
0497         cf->data[1] = (bec.txerr > bec.rxerr) ?
0498             CAN_ERR_CRTL_TX_WARNING :
0499             CAN_ERR_CRTL_RX_WARNING;
0500         cf->data[6] = bec.txerr;
0501         cf->data[7] = bec.rxerr;
0502         break;
0503     case CAN_STATE_ERROR_PASSIVE:
0504         /* error passive state */
0505         cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;
0506         cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;
0507         if (bec.txerr > 127)
0508             cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;
0509         cf->data[6] = bec.txerr;
0510         cf->data[7] = bec.rxerr;
0511         break;
0512     case CAN_STATE_BUS_OFF:
0513         /* bus-off state */
0514         cf->can_id |= CAN_ERR_BUSOFF;
0515         break;
0516     default:
0517         break;
0518     }
0519 
0520     netif_receive_skb(skb);
0521 
0522     return 1;
0523 }
0524 
0525 static int ifi_canfd_handle_state_errors(struct net_device *ndev)
0526 {
0527     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0528     u32 stcmd = readl(priv->base + IFI_CANFD_STCMD);
0529     int work_done = 0;
0530 
0531     if ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) &&
0532         (priv->can.state != CAN_STATE_ERROR_ACTIVE)) {
0533         netdev_dbg(ndev, "Error, entered active state\n");
0534         work_done += ifi_canfd_handle_state_change(ndev,
0535                         CAN_STATE_ERROR_ACTIVE);
0536     }
0537 
0538     if ((stcmd & IFI_CANFD_STCMD_ERROR_WARNING) &&
0539         (priv->can.state != CAN_STATE_ERROR_WARNING)) {
0540         netdev_dbg(ndev, "Error, entered warning state\n");
0541         work_done += ifi_canfd_handle_state_change(ndev,
0542                         CAN_STATE_ERROR_WARNING);
0543     }
0544 
0545     if ((stcmd & IFI_CANFD_STCMD_ERROR_PASSIVE) &&
0546         (priv->can.state != CAN_STATE_ERROR_PASSIVE)) {
0547         netdev_dbg(ndev, "Error, entered passive state\n");
0548         work_done += ifi_canfd_handle_state_change(ndev,
0549                         CAN_STATE_ERROR_PASSIVE);
0550     }
0551 
0552     if ((stcmd & IFI_CANFD_STCMD_BUSOFF) &&
0553         (priv->can.state != CAN_STATE_BUS_OFF)) {
0554         netdev_dbg(ndev, "Error, entered bus-off state\n");
0555         work_done += ifi_canfd_handle_state_change(ndev,
0556                         CAN_STATE_BUS_OFF);
0557     }
0558 
0559     return work_done;
0560 }
0561 
0562 static int ifi_canfd_poll(struct napi_struct *napi, int quota)
0563 {
0564     struct net_device *ndev = napi->dev;
0565     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0566     u32 rxstcmd = readl(priv->base + IFI_CANFD_RXSTCMD);
0567     int work_done = 0;
0568 
0569     /* Handle bus state changes */
0570     work_done += ifi_canfd_handle_state_errors(ndev);
0571 
0572     /* Handle lost messages on RX */
0573     if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW)
0574         work_done += ifi_canfd_handle_lost_msg(ndev);
0575 
0576     /* Handle lec errors on the bus */
0577     if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
0578         work_done += ifi_canfd_handle_lec_err(ndev);
0579 
0580     /* Handle normal messages on RX */
0581     if (!(rxstcmd & IFI_CANFD_RXSTCMD_EMPTY))
0582         work_done += ifi_canfd_do_rx_poll(ndev, quota - work_done);
0583 
0584     if (work_done < quota) {
0585         napi_complete_done(napi, work_done);
0586         ifi_canfd_irq_enable(ndev, 1);
0587     }
0588 
0589     return work_done;
0590 }
0591 
0592 static irqreturn_t ifi_canfd_isr(int irq, void *dev_id)
0593 {
0594     struct net_device *ndev = (struct net_device *)dev_id;
0595     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0596     struct net_device_stats *stats = &ndev->stats;
0597     const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |
0598                 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER |
0599                 IFI_CANFD_INTERRUPT_ERROR_COUNTER |
0600                 IFI_CANFD_INTERRUPT_ERROR_STATE_CHG |
0601                 IFI_CANFD_INTERRUPT_ERROR_WARNING |
0602                 IFI_CANFD_INTERRUPT_ERROR_BUSOFF;
0603     const u32 tx_irq_mask = IFI_CANFD_INTERRUPT_TXFIFO_EMPTY |
0604                 IFI_CANFD_INTERRUPT_TXFIFO_REMOVE;
0605     const u32 clr_irq_mask = ~((u32)IFI_CANFD_INTERRUPT_SET_IRQ);
0606     u32 isr;
0607 
0608     isr = readl(priv->base + IFI_CANFD_INTERRUPT);
0609 
0610     /* No interrupt */
0611     if (isr == 0)
0612         return IRQ_NONE;
0613 
0614     /* Clear all pending interrupts but ErrWarn */
0615     writel(clr_irq_mask, priv->base + IFI_CANFD_INTERRUPT);
0616 
0617     /* RX IRQ or bus warning, start NAPI */
0618     if (isr & rx_irq_mask) {
0619         ifi_canfd_irq_enable(ndev, 0);
0620         napi_schedule(&priv->napi);
0621     }
0622 
0623     /* TX IRQ */
0624     if (isr & IFI_CANFD_INTERRUPT_TXFIFO_REMOVE) {
0625         stats->tx_bytes += can_get_echo_skb(ndev, 0, NULL);
0626         stats->tx_packets++;
0627     }
0628 
0629     if (isr & tx_irq_mask)
0630         netif_wake_queue(ndev);
0631 
0632     return IRQ_HANDLED;
0633 }
0634 
0635 static const struct can_bittiming_const ifi_canfd_bittiming_const = {
0636     .name       = KBUILD_MODNAME,
0637     .tseg1_min  = 1,    /* Time segment 1 = prop_seg + phase_seg1 */
0638     .tseg1_max  = 256,
0639     .tseg2_min  = 2,    /* Time segment 2 = phase_seg2 */
0640     .tseg2_max  = 256,
0641     .sjw_max    = 128,
0642     .brp_min    = 2,
0643     .brp_max    = 512,
0644     .brp_inc    = 1,
0645 };
0646 
0647 static void ifi_canfd_set_bittiming(struct net_device *ndev)
0648 {
0649     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0650     const struct can_bittiming *bt = &priv->can.bittiming;
0651     const struct can_bittiming *dbt = &priv->can.data_bittiming;
0652     u16 brp, sjw, tseg1, tseg2, tdc;
0653 
0654     /* Configure bit timing */
0655     brp = bt->brp - 2;
0656     sjw = bt->sjw - 1;
0657     tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
0658     tseg2 = bt->phase_seg2 - 2;
0659     writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |
0660            (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |
0661            (brp << IFI_CANFD_TIME_PRESCALE_OFF) |
0662            (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8),
0663            priv->base + IFI_CANFD_TIME);
0664 
0665     /* Configure data bit timing */
0666     brp = dbt->brp - 2;
0667     sjw = dbt->sjw - 1;
0668     tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
0669     tseg2 = dbt->phase_seg2 - 2;
0670     writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |
0671            (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |
0672            (brp << IFI_CANFD_TIME_PRESCALE_OFF) |
0673            (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8),
0674            priv->base + IFI_CANFD_FTIME);
0675 
0676     /* Configure transmitter delay */
0677     tdc = dbt->brp * (dbt->prop_seg + dbt->phase_seg1);
0678     tdc &= IFI_CANFD_TDELAY_MASK;
0679     writel(IFI_CANFD_TDELAY_EN | tdc, priv->base + IFI_CANFD_TDELAY);
0680 }
0681 
0682 static void ifi_canfd_set_filter(struct net_device *ndev, const u32 id,
0683                  const u32 mask, const u32 ident)
0684 {
0685     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0686 
0687     writel(mask, priv->base + IFI_CANFD_FILTER_MASK(id));
0688     writel(ident, priv->base + IFI_CANFD_FILTER_IDENT(id));
0689 }
0690 
0691 static void ifi_canfd_set_filters(struct net_device *ndev)
0692 {
0693     /* Receive all CAN frames (standard ID) */
0694     ifi_canfd_set_filter(ndev, 0,
0695                  IFI_CANFD_FILTER_MASK_VALID |
0696                  IFI_CANFD_FILTER_MASK_EXT,
0697                  IFI_CANFD_FILTER_IDENT_VALID);
0698 
0699     /* Receive all CAN frames (extended ID) */
0700     ifi_canfd_set_filter(ndev, 1,
0701                  IFI_CANFD_FILTER_MASK_VALID |
0702                  IFI_CANFD_FILTER_MASK_EXT,
0703                  IFI_CANFD_FILTER_IDENT_VALID |
0704                  IFI_CANFD_FILTER_IDENT_IDE);
0705 
0706     /* Receive all CANFD frames */
0707     ifi_canfd_set_filter(ndev, 2,
0708                  IFI_CANFD_FILTER_MASK_VALID |
0709                  IFI_CANFD_FILTER_MASK_EDL |
0710                  IFI_CANFD_FILTER_MASK_EXT,
0711                  IFI_CANFD_FILTER_IDENT_VALID |
0712                  IFI_CANFD_FILTER_IDENT_CANFD |
0713                  IFI_CANFD_FILTER_IDENT_IDE);
0714 }
0715 
0716 static void ifi_canfd_start(struct net_device *ndev)
0717 {
0718     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0719     u32 stcmd;
0720 
0721     /* Reset the IP */
0722     writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
0723     writel(IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING,
0724            priv->base + IFI_CANFD_STCMD);
0725 
0726     ifi_canfd_set_bittiming(ndev);
0727     ifi_canfd_set_filters(ndev);
0728 
0729     /* Reset FIFOs */
0730     writel(IFI_CANFD_RXSTCMD_RESET, priv->base + IFI_CANFD_RXSTCMD);
0731     writel(0, priv->base + IFI_CANFD_RXSTCMD);
0732     writel(IFI_CANFD_TXSTCMD_RESET, priv->base + IFI_CANFD_TXSTCMD);
0733     writel(0, priv->base + IFI_CANFD_TXSTCMD);
0734 
0735     /* Repeat transmission until successful */
0736     writel(0, priv->base + IFI_CANFD_REPEAT);
0737     writel(0, priv->base + IFI_CANFD_SUSPEND);
0738 
0739     /* Clear all pending interrupts */
0740     writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
0741            priv->base + IFI_CANFD_INTERRUPT);
0742 
0743     stcmd = IFI_CANFD_STCMD_ENABLE | IFI_CANFD_STCMD_NORMAL_MODE |
0744         IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING;
0745 
0746     if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
0747         stcmd |= IFI_CANFD_STCMD_BUSMONITOR;
0748 
0749     if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
0750         stcmd |= IFI_CANFD_STCMD_LOOPBACK;
0751 
0752     if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) &&
0753         !(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO))
0754         stcmd |= IFI_CANFD_STCMD_ENABLE_ISO;
0755 
0756     if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))
0757         stcmd |= IFI_CANFD_STCMD_DISABLE_CANFD;
0758 
0759     priv->can.state = CAN_STATE_ERROR_ACTIVE;
0760 
0761     ifi_canfd_irq_enable(ndev, 1);
0762 
0763     /* Unlock, reset and enable the error counter. */
0764     writel(IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC,
0765            priv->base + IFI_CANFD_ERROR_CTR);
0766     writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);
0767     writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR);
0768 
0769     /* Enable controller */
0770     writel(stcmd, priv->base + IFI_CANFD_STCMD);
0771 }
0772 
0773 static void ifi_canfd_stop(struct net_device *ndev)
0774 {
0775     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0776 
0777     /* Reset and disable the error counter. */
0778     writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);
0779     writel(0, priv->base + IFI_CANFD_ERROR_CTR);
0780 
0781     /* Reset the IP */
0782     writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
0783 
0784     /* Mask all interrupts */
0785     writel(~0, priv->base + IFI_CANFD_IRQMASK);
0786 
0787     /* Clear all pending interrupts */
0788     writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
0789            priv->base + IFI_CANFD_INTERRUPT);
0790 
0791     /* Set the state as STOPPED */
0792     priv->can.state = CAN_STATE_STOPPED;
0793 }
0794 
0795 static int ifi_canfd_set_mode(struct net_device *ndev, enum can_mode mode)
0796 {
0797     switch (mode) {
0798     case CAN_MODE_START:
0799         ifi_canfd_start(ndev);
0800         netif_wake_queue(ndev);
0801         break;
0802     default:
0803         return -EOPNOTSUPP;
0804     }
0805 
0806     return 0;
0807 }
0808 
0809 static int ifi_canfd_open(struct net_device *ndev)
0810 {
0811     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0812     int ret;
0813 
0814     ret = open_candev(ndev);
0815     if (ret) {
0816         netdev_err(ndev, "Failed to open CAN device\n");
0817         return ret;
0818     }
0819 
0820     /* Register interrupt handler */
0821     ret = request_irq(ndev->irq, ifi_canfd_isr, IRQF_SHARED,
0822               ndev->name, ndev);
0823     if (ret < 0) {
0824         netdev_err(ndev, "Failed to request interrupt\n");
0825         goto err_irq;
0826     }
0827 
0828     ifi_canfd_start(ndev);
0829 
0830     napi_enable(&priv->napi);
0831     netif_start_queue(ndev);
0832 
0833     return 0;
0834 err_irq:
0835     close_candev(ndev);
0836     return ret;
0837 }
0838 
0839 static int ifi_canfd_close(struct net_device *ndev)
0840 {
0841     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0842 
0843     netif_stop_queue(ndev);
0844     napi_disable(&priv->napi);
0845 
0846     ifi_canfd_stop(ndev);
0847 
0848     free_irq(ndev->irq, ndev);
0849 
0850     close_candev(ndev);
0851 
0852     return 0;
0853 }
0854 
0855 static netdev_tx_t ifi_canfd_start_xmit(struct sk_buff *skb,
0856                     struct net_device *ndev)
0857 {
0858     struct ifi_canfd_priv *priv = netdev_priv(ndev);
0859     struct canfd_frame *cf = (struct canfd_frame *)skb->data;
0860     u32 txst, txid, txdlc;
0861     int i;
0862 
0863     if (can_dropped_invalid_skb(ndev, skb))
0864         return NETDEV_TX_OK;
0865 
0866     /* Check if the TX buffer is full */
0867     txst = readl(priv->base + IFI_CANFD_TXSTCMD);
0868     if (txst & IFI_CANFD_TXSTCMD_FULL) {
0869         netif_stop_queue(ndev);
0870         netdev_err(ndev, "BUG! TX FIFO full when queue awake!\n");
0871         return NETDEV_TX_BUSY;
0872     }
0873 
0874     netif_stop_queue(ndev);
0875 
0876     if (cf->can_id & CAN_EFF_FLAG) {
0877         txid = cf->can_id & CAN_EFF_MASK;
0878         /*
0879          * In case the Extended ID frame is transmitted, the
0880          * standard and extended part of the ID are swapped
0881          * in the register, so swap them back to send the
0882          * correct ID.
0883          */
0884         txid = (txid >> IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH) |
0885                ((txid & IFI_CANFD_TXFIFO_ID_ID_XTD_MASK) <<
0886                  IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET);
0887         txid |= IFI_CANFD_TXFIFO_ID_IDE;
0888     } else {
0889         txid = cf->can_id & CAN_SFF_MASK;
0890     }
0891 
0892     txdlc = can_fd_len2dlc(cf->len);
0893     if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) {
0894         txdlc |= IFI_CANFD_TXFIFO_DLC_EDL;
0895         if (cf->flags & CANFD_BRS)
0896             txdlc |= IFI_CANFD_TXFIFO_DLC_BRS;
0897     }
0898 
0899     if (cf->can_id & CAN_RTR_FLAG)
0900         txdlc |= IFI_CANFD_TXFIFO_DLC_RTR;
0901 
0902     /* message ram configuration */
0903     writel(txid, priv->base + IFI_CANFD_TXFIFO_ID);
0904     writel(txdlc, priv->base + IFI_CANFD_TXFIFO_DLC);
0905 
0906     for (i = 0; i < cf->len; i += 4) {
0907         writel(*(u32 *)(cf->data + i),
0908                priv->base + IFI_CANFD_TXFIFO_DATA + i);
0909     }
0910 
0911     writel(0, priv->base + IFI_CANFD_TXFIFO_REPEATCOUNT);
0912     writel(0, priv->base + IFI_CANFD_TXFIFO_SUSPEND_US);
0913 
0914     can_put_echo_skb(skb, ndev, 0, 0);
0915 
0916     /* Start the transmission */
0917     writel(IFI_CANFD_TXSTCMD_ADD_MSG, priv->base + IFI_CANFD_TXSTCMD);
0918 
0919     return NETDEV_TX_OK;
0920 }
0921 
0922 static const struct net_device_ops ifi_canfd_netdev_ops = {
0923     .ndo_open   = ifi_canfd_open,
0924     .ndo_stop   = ifi_canfd_close,
0925     .ndo_start_xmit = ifi_canfd_start_xmit,
0926     .ndo_change_mtu = can_change_mtu,
0927 };
0928 
0929 static const struct ethtool_ops ifi_canfd_ethtool_ops = {
0930     .get_ts_info = ethtool_op_get_ts_info,
0931 };
0932 
0933 static int ifi_canfd_plat_probe(struct platform_device *pdev)
0934 {
0935     struct device *dev = &pdev->dev;
0936     struct net_device *ndev;
0937     struct ifi_canfd_priv *priv;
0938     void __iomem *addr;
0939     int irq, ret;
0940     u32 id, rev;
0941 
0942     addr = devm_platform_ioremap_resource(pdev, 0);
0943     if (IS_ERR(addr))
0944         return PTR_ERR(addr);
0945 
0946     irq = platform_get_irq(pdev, 0);
0947     if (irq < 0)
0948         return -EINVAL;
0949 
0950     id = readl(addr + IFI_CANFD_IP_ID);
0951     if (id != IFI_CANFD_IP_ID_VALUE) {
0952         dev_err(dev, "This block is not IFI CANFD, id=%08x\n", id);
0953         return -EINVAL;
0954     }
0955 
0956     rev = readl(addr + IFI_CANFD_VER) & IFI_CANFD_VER_REV_MASK;
0957     if (rev < IFI_CANFD_VER_REV_MIN_SUPPORTED) {
0958         dev_err(dev, "This block is too old (rev %i), minimum supported is rev %i\n",
0959             rev, IFI_CANFD_VER_REV_MIN_SUPPORTED);
0960         return -EINVAL;
0961     }
0962 
0963     ndev = alloc_candev(sizeof(*priv), 1);
0964     if (!ndev)
0965         return -ENOMEM;
0966 
0967     ndev->irq = irq;
0968     ndev->flags |= IFF_ECHO;    /* we support local echo */
0969     ndev->netdev_ops = &ifi_canfd_netdev_ops;
0970     ndev->ethtool_ops = &ifi_canfd_ethtool_ops;
0971 
0972     priv = netdev_priv(ndev);
0973     priv->ndev = ndev;
0974     priv->base = addr;
0975 
0976     netif_napi_add(ndev, &priv->napi, ifi_canfd_poll, 64);
0977 
0978     priv->can.state = CAN_STATE_STOPPED;
0979 
0980     priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK);
0981 
0982     priv->can.bittiming_const   = &ifi_canfd_bittiming_const;
0983     priv->can.data_bittiming_const  = &ifi_canfd_bittiming_const;
0984     priv->can.do_set_mode       = ifi_canfd_set_mode;
0985     priv->can.do_get_berr_counter   = ifi_canfd_get_berr_counter;
0986 
0987     /* IFI CANFD can do both Bosch FD and ISO FD */
0988     priv->can.ctrlmode = CAN_CTRLMODE_FD;
0989 
0990     /* IFI CANFD can do both Bosch FD and ISO FD */
0991     priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
0992                        CAN_CTRLMODE_LISTENONLY |
0993                        CAN_CTRLMODE_FD |
0994                        CAN_CTRLMODE_FD_NON_ISO |
0995                        CAN_CTRLMODE_BERR_REPORTING;
0996 
0997     platform_set_drvdata(pdev, ndev);
0998     SET_NETDEV_DEV(ndev, dev);
0999 
1000     ret = register_candev(ndev);
1001     if (ret) {
1002         dev_err(dev, "Failed to register (ret=%d)\n", ret);
1003         goto err_reg;
1004     }
1005 
1006     dev_info(dev, "Driver registered: regs=%p, irq=%d, clock=%d\n",
1007          priv->base, ndev->irq, priv->can.clock.freq);
1008 
1009     return 0;
1010 
1011 err_reg:
1012     free_candev(ndev);
1013     return ret;
1014 }
1015 
1016 static int ifi_canfd_plat_remove(struct platform_device *pdev)
1017 {
1018     struct net_device *ndev = platform_get_drvdata(pdev);
1019 
1020     unregister_candev(ndev);
1021     platform_set_drvdata(pdev, NULL);
1022     free_candev(ndev);
1023 
1024     return 0;
1025 }
1026 
1027 static const struct of_device_id ifi_canfd_of_table[] = {
1028     { .compatible = "ifi,canfd-1.0", .data = NULL },
1029     { /* sentinel */ },
1030 };
1031 MODULE_DEVICE_TABLE(of, ifi_canfd_of_table);
1032 
1033 static struct platform_driver ifi_canfd_plat_driver = {
1034     .driver = {
1035         .name       = KBUILD_MODNAME,
1036         .of_match_table = ifi_canfd_of_table,
1037     },
1038     .probe  = ifi_canfd_plat_probe,
1039     .remove = ifi_canfd_plat_remove,
1040 };
1041 
1042 module_platform_driver(ifi_canfd_plat_driver);
1043 
1044 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
1045 MODULE_LICENSE("GPL v2");
1046 MODULE_DESCRIPTION("CAN bus driver for IFI CANFD controller");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!