1
2
3
4
5
6
7
8
9
10
11
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
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
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
209struct ifi_canfd_priv {
210 struct can_priv can;
211 struct napi_struct napi;
212 struct net_device *ndev;
213 void __iomem *base;
214};
215
216static 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
235static 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
271
272
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
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
311static 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
341static 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
364static 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))
379 return 0;
380
381 priv->can.can_stats.bus_error++;
382 stats->rx_errors++;
383
384
385 skb = alloc_can_err_skb(ndev, &cf);
386 if (unlikely(!skb))
387 return 0;
388
389
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
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
426static 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
441static 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
453 priv->can.can_stats.error_warning++;
454 priv->can.state = CAN_STATE_ERROR_WARNING;
455 break;
456 case CAN_STATE_ERROR_PASSIVE:
457
458 priv->can.can_stats.error_passive++;
459 priv->can.state = CAN_STATE_ERROR_PASSIVE;
460 break;
461 case CAN_STATE_BUS_OFF:
462
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
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
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
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
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
513static 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
521
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
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
551static 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
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
569 if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW)
570 work_done += ifi_canfd_handle_lost_msg(ndev);
571
572
573 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
574 work_done += ifi_canfd_handle_lec_err(ndev, errctr);
575
576
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
588static 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
606 if (isr == 0)
607 return IRQ_NONE;
608
609
610 writel(clr_irq_mask, priv->base + IFI_CANFD_INTERRUPT);
611
612
613 if (isr & rx_irq_mask) {
614 ifi_canfd_irq_enable(ndev, 0);
615 napi_schedule(&priv->napi);
616 }
617
618
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
631static const struct can_bittiming_const ifi_canfd_bittiming_const = {
632 .name = KBUILD_MODNAME,
633 .tseg1_min = 1,
634 .tseg1_max = 256,
635 .tseg2_min = 2,
636 .tseg2_max = 256,
637 .sjw_max = 128,
638 .brp_min = 2,
639 .brp_max = 512,
640 .brp_inc = 1,
641};
642
643static 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
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
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
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
678static 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
687static void ifi_canfd_set_filters(struct net_device *ndev)
688{
689
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
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
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
712static void ifi_canfd_start(struct net_device *ndev)
713{
714 struct ifi_canfd_priv *priv = netdev_priv(ndev);
715 u32 stcmd;
716
717
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
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
732 writel(0, priv->base + IFI_CANFD_REPEAT);
733 writel(0, priv->base + IFI_CANFD_SUSPEND);
734
735
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
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
766 writel(stcmd, priv->base + IFI_CANFD_STCMD);
767}
768
769static void ifi_canfd_stop(struct net_device *ndev)
770{
771 struct ifi_canfd_priv *priv = netdev_priv(ndev);
772
773
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
778 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
779
780
781 writel(~0, priv->base + IFI_CANFD_IRQMASK);
782
783
784 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
785 priv->base + IFI_CANFD_INTERRUPT);
786
787
788 priv->can.state = CAN_STATE_STOPPED;
789}
790
791static 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
805static 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
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;
831err_irq:
832 close_candev(ndev);
833 return ret;
834}
835
836static 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
854static 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
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
879
880
881
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
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
916 writel(IFI_CANFD_TXSTCMD_ADD_MSG, priv->base + IFI_CANFD_TXSTCMD);
917
918 return NETDEV_TX_OK;
919}
920
921static 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
928static 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;
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
974 priv->can.ctrlmode = CAN_CTRLMODE_FD;
975
976
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
999err_reg:
1000 free_candev(ndev);
1001 return ret;
1002}
1003
1004static 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
1015static const struct of_device_id ifi_canfd_of_table[] = {
1016 { .compatible = "ifi,canfd-1.0", .data = NULL },
1017 { },
1018};
1019MODULE_DEVICE_TABLE(of, ifi_canfd_of_table);
1020
1021static 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
1030module_platform_driver(ifi_canfd_plat_driver);
1031
1032MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
1033MODULE_LICENSE("GPL v2");
1034MODULE_DESCRIPTION("CAN bus driver for IFI CANFD controller");
1035
