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