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