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