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