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