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