]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/net/can/ifi_canfd/ifi_canfd.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
can: ifi: Fix TX DLC configuration
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / can / ifi_canfd / ifi_canfd.c
CommitLineData
0c4d9c94
MV		 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,
99312c37 517 .tseg1_min = 1, /* Time segment 1 = prop_seg + phase_seg1 */
0c4d9c94 518 .tseg1_max = 64,
99312c37
MV		 519 .tseg2_min = 2, /* Time segment 2 = phase_seg2 */
520 .tseg2_max = 64,
0c4d9c94 521 .sjw_max = 16,
99312c37
MV		 522 .brp_min = 2,
523 .brp_max = 256,
0c4d9c94
MV		 524 .brp_inc = 1,
525};
526
527static const struct can_bittiming_const ifi_canfd_data_bittiming_const = {
528 .name = KBUILD_MODNAME,
99312c37
MV		 529 .tseg1_min = 1, /* Time segment 1 = prop_seg + phase_seg1 */
530 .tseg1_max = 64,
531 .tseg2_min = 2, /* Time segment 2 = phase_seg2 */
532 .tseg2_max = 64,
533 .sjw_max = 16,
534 .brp_min = 2,
535 .brp_max = 256,
0c4d9c94
MV		 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
99312c37
MV		 548 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) &&
549 !(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO)) {
550 time_off = IFI_CANFD_TIME_SJW_OFF_ISO;
551 } else {
0c4d9c94
MV		 552 noniso_arg = IFI_CANFD_TIME_SET_TIMEB_BOSCH |
553 IFI_CANFD_TIME_SET_TIMEA_BOSCH |
554 IFI_CANFD_TIME_SET_PRESC_BOSCH |
555 IFI_CANFD_TIME_SET_SJW_BOSCH;
556 time_off = IFI_CANFD_TIME_SJW_OFF_BOSCH;
0c4d9c94
MV		 557 }
558
559 /* Configure bit timing */
99312c37 560 brp = bt->brp - 2;
0c4d9c94
MV		 561 sjw = bt->sjw - 1;
562 tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
99312c37 563 tseg2 = bt->phase_seg2 - 2;
0c4d9c94
MV		 564 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |
565 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |
566 (brp << IFI_CANFD_TIME_PRESCALE_OFF) |
99312c37
MV		 567 (sjw << time_off) |
568 noniso_arg,
0c4d9c94
MV		 569 priv->base + IFI_CANFD_TIME);
570
571 /* Configure data bit timing */
99312c37 572 brp = dbt->brp - 2;
0c4d9c94
MV		 573 sjw = dbt->sjw - 1;
574 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
99312c37 575 tseg2 = dbt->phase_seg2 - 2;
0c4d9c94
MV		 576 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |
577 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |
578 (brp << IFI_CANFD_TIME_PRESCALE_OFF) |
579 (sjw << time_off) |
580 noniso_arg,
581 priv->base + IFI_CANFD_FTIME);
582}
583
584static void ifi_canfd_set_filter(struct net_device *ndev, const u32 id,
585 const u32 mask, const u32 ident)
586{
587 struct ifi_canfd_priv *priv = netdev_priv(ndev);
588
589 writel(mask, priv->base + IFI_CANFD_FILTER_MASK(id));
590 writel(ident, priv->base + IFI_CANFD_FILTER_IDENT(id));
591}
592
593static void ifi_canfd_set_filters(struct net_device *ndev)
594{
595 /* Receive all CAN frames (standard ID) */
596 ifi_canfd_set_filter(ndev, 0,
597 IFI_CANFD_FILTER_MASK_VALID |
598 IFI_CANFD_FILTER_MASK_EXT,
599 IFI_CANFD_FILTER_IDENT_VALID);
600
601 /* Receive all CAN frames (extended ID) */
602 ifi_canfd_set_filter(ndev, 1,
603 IFI_CANFD_FILTER_MASK_VALID |
604 IFI_CANFD_FILTER_MASK_EXT,
605 IFI_CANFD_FILTER_IDENT_VALID |
606 IFI_CANFD_FILTER_IDENT_IDE);
607
608 /* Receive all CANFD frames */
609 ifi_canfd_set_filter(ndev, 2,
610 IFI_CANFD_FILTER_MASK_VALID |
611 IFI_CANFD_FILTER_MASK_EDL |
612 IFI_CANFD_FILTER_MASK_EXT,
613 IFI_CANFD_FILTER_IDENT_VALID |
614 IFI_CANFD_FILTER_IDENT_CANFD |
615 IFI_CANFD_FILTER_IDENT_IDE);
616}
617
618static void ifi_canfd_start(struct net_device *ndev)
619{
620 struct ifi_canfd_priv *priv = netdev_priv(ndev);
621 u32 stcmd;
622
623 /* Reset the IP */
624 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
625 writel(0, priv->base + IFI_CANFD_STCMD);
626
627 ifi_canfd_set_bittiming(ndev);
628 ifi_canfd_set_filters(ndev);
629
630 /* Reset FIFOs */
631 writel(IFI_CANFD_RXSTCMD_RESET, priv->base + IFI_CANFD_RXSTCMD);
632 writel(0, priv->base + IFI_CANFD_RXSTCMD);
633 writel(IFI_CANFD_TXSTCMD_RESET, priv->base + IFI_CANFD_TXSTCMD);
634 writel(0, priv->base + IFI_CANFD_TXSTCMD);
635
636 /* Repeat transmission until successful */
637 writel(0, priv->base + IFI_CANFD_REPEAT);
638 writel(0, priv->base + IFI_CANFD_SUSPEND);
639
640 /* Clear all pending interrupts */
641 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
642 priv->base + IFI_CANFD_INTERRUPT);
643
644 stcmd = IFI_CANFD_STCMD_ENABLE | IFI_CANFD_STCMD_NORMAL_MODE;
645
646 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
647 stcmd |= IFI_CANFD_STCMD_BUSMONITOR;
648
649 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
650 stcmd |= IFI_CANFD_STCMD_LOOPBACK;
651
652 if (priv->can.ctrlmode & CAN_CTRLMODE_FD)
653 stcmd |= IFI_CANFD_STCMD_ENABLE_ISO;
654
655 if (!(priv->can.ctrlmode & (CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO)))
656 stcmd |= IFI_CANFD_STCMD_DISABLE_CANFD;
657
658 priv->can.state = CAN_STATE_ERROR_ACTIVE;
659
660 ifi_canfd_irq_enable(ndev, 1);
661
662 /* Enable controller */
663 writel(stcmd, priv->base + IFI_CANFD_STCMD);
664}
665
666static void ifi_canfd_stop(struct net_device *ndev)
667{
668 struct ifi_canfd_priv *priv = netdev_priv(ndev);
669
670 /* Reset the IP */
671 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);
672
673 /* Mask all interrupts */
674 writel(~0, priv->base + IFI_CANFD_IRQMASK);
675
676 /* Clear all pending interrupts */
677 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),
678 priv->base + IFI_CANFD_INTERRUPT);
679
680 /* Set the state as STOPPED */
681 priv->can.state = CAN_STATE_STOPPED;
682}
683
684static int ifi_canfd_set_mode(struct net_device *ndev, enum can_mode mode)
685{
686 switch (mode) {
687 case CAN_MODE_START:
688 ifi_canfd_start(ndev);
689 netif_wake_queue(ndev);
690 break;
691 default:
692 return -EOPNOTSUPP;
693 }
694
695 return 0;
696}
697
698static int ifi_canfd_open(struct net_device *ndev)
699{
700 struct ifi_canfd_priv *priv = netdev_priv(ndev);
701 int ret;
702
703 ret = open_candev(ndev);
704 if (ret) {
705 netdev_err(ndev, "Failed to open CAN device\n");
706 return ret;
707 }
708
709 /* Register interrupt handler */
710 ret = request_irq(ndev->irq, ifi_canfd_isr, IRQF_SHARED,
711 ndev->name, ndev);
712 if (ret < 0) {
713 netdev_err(ndev, "Failed to request interrupt\n");
714 goto err_irq;
715 }
716
717 ifi_canfd_start(ndev);
718
719 can_led_event(ndev, CAN_LED_EVENT_OPEN);
720 napi_enable(&priv->napi);
721 netif_start_queue(ndev);
722
723 return 0;
724err_irq:
725 close_candev(ndev);
726 return ret;
727}
728
729static int ifi_canfd_close(struct net_device *ndev)
730{
731 struct ifi_canfd_priv *priv = netdev_priv(ndev);
732
733 netif_stop_queue(ndev);
734 napi_disable(&priv->napi);
735
736 ifi_canfd_stop(ndev);
737
738 free_irq(ndev->irq, ndev);
739
740 close_candev(ndev);
741
742 can_led_event(ndev, CAN_LED_EVENT_STOP);
743
744 return 0;
745}
746
747static netdev_tx_t ifi_canfd_start_xmit(struct sk_buff *skb,
748 struct net_device *ndev)
749{
750 struct ifi_canfd_priv *priv = netdev_priv(ndev);
751 struct canfd_frame *cf = (struct canfd_frame *)skb->data;
f1deaee0 752 u32 txst, txid, txdlc;
0c4d9c94
MV		 753 int i;
754
755 if (can_dropped_invalid_skb(ndev, skb))
756 return NETDEV_TX_OK;
757
758 /* Check if the TX buffer is full */
759 txst = readl(priv->base + IFI_CANFD_TXSTCMD);
760 if (txst & IFI_CANFD_TXSTCMD_FULL) {
761 netif_stop_queue(ndev);
762 netdev_err(ndev, "BUG! TX FIFO full when queue awake!\n");
763 return NETDEV_TX_BUSY;
764 }
765
766 netif_stop_queue(ndev);
767
768 if (cf->can_id & CAN_EFF_FLAG) {
769 txid = cf->can_id & CAN_EFF_MASK;
770 txid |= IFI_CANFD_TXFIFO_ID_IDE;
771 } else {
772 txid = cf->can_id & CAN_SFF_MASK;
773 }
774
f1deaee0
MV		 775 txdlc = can_len2dlc(cf->len);
776 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) {
777 txdlc |= IFI_CANFD_TXFIFO_DLC_EDL;
778 if (cf->flags & CANFD_BRS)
779 txdlc |= IFI_CANFD_TXFIFO_DLC_BRS;
0c4d9c94
MV		 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
99312c37 850 priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK);
0c4d9c94
MV		 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");
Ubuntu Hirsute Linux kernel mirror