1 /*
2 * sun4i_can.c - CAN bus controller driver for Allwinner SUN4I&SUN7I based SoCs
3 *
4 * Copyright (C) 2013 Peter Chen
5 * Copyright (C) 2015 Gerhard Bertelsmann
6 * All rights reserved.
7 *
8 * Parts of this software are based on (derived from) the SJA1000 code by:
9 * Copyright (C) 2014 Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
10 * Copyright (C) 2007 Wolfgang Grandegger <wg@grandegger.com>
11 * Copyright (C) 2002-2007 Volkswagen Group Electronic Research
12 * Copyright (C) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33,
13 * 38106 Braunschweig, GERMANY
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
17 * are met:
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
23 * 3. Neither the name of Volkswagen nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * Alternatively, provided that this notice is retained in full, this
28 * software may be distributed under the terms of the GNU General
29 * Public License ("GPL") version 2, in which case the provisions of the
30 * GPL apply INSTEAD OF those given above.
31 *
32 * The provided data structures and external interfaces from this code
33 * are not restricted to be used by modules with a GPL compatible license.
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
36 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
37 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
38 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
39 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
41 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
42 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
43 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
44 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
45 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
46 * DAMAGE.
47 *
48 */
49
50 #include <linux/netdevice.h>
51 #include <linux/can.h>
52 #include <linux/can/dev.h>
53 #include <linux/can/error.h>
54 #include <linux/clk.h>
55 #include <linux/delay.h>
56 #include <linux/ethtool.h>
57 #include <linux/interrupt.h>
58 #include <linux/init.h>
59 #include <linux/io.h>
60 #include <linux/module.h>
61 #include <linux/of.h>
62 #include <linux/platform_device.h>
63 #include <linux/reset.h>
64
65 #define DRV_NAME "sun4i_can"
66
67 /* Registers address (physical base address 0x01C2BC00) */
68 #define SUN4I_REG_MSEL_ADDR 0x0000 /* CAN Mode Select */
69 #define SUN4I_REG_CMD_ADDR 0x0004 /* CAN Command */
70 #define SUN4I_REG_STA_ADDR 0x0008 /* CAN Status */
71 #define SUN4I_REG_INT_ADDR 0x000c /* CAN Interrupt Flag */
72 #define SUN4I_REG_INTEN_ADDR 0x0010 /* CAN Interrupt Enable */
73 #define SUN4I_REG_BTIME_ADDR 0x0014 /* CAN Bus Timing 0 */
74 #define SUN4I_REG_TEWL_ADDR 0x0018 /* CAN Tx Error Warning Limit */
75 #define SUN4I_REG_ERRC_ADDR 0x001c /* CAN Error Counter */
76 #define SUN4I_REG_RMCNT_ADDR 0x0020 /* CAN Receive Message Counter */
77 #define SUN4I_REG_RBUFSA_ADDR 0x0024 /* CAN Receive Buffer Start Address */
78 #define SUN4I_REG_BUF0_ADDR 0x0040 /* CAN Tx/Rx Buffer 0 */
79 #define SUN4I_REG_BUF1_ADDR 0x0044 /* CAN Tx/Rx Buffer 1 */
80 #define SUN4I_REG_BUF2_ADDR 0x0048 /* CAN Tx/Rx Buffer 2 */
81 #define SUN4I_REG_BUF3_ADDR 0x004c /* CAN Tx/Rx Buffer 3 */
82 #define SUN4I_REG_BUF4_ADDR 0x0050 /* CAN Tx/Rx Buffer 4 */
83 #define SUN4I_REG_BUF5_ADDR 0x0054 /* CAN Tx/Rx Buffer 5 */
84 #define SUN4I_REG_BUF6_ADDR 0x0058 /* CAN Tx/Rx Buffer 6 */
85 #define SUN4I_REG_BUF7_ADDR 0x005c /* CAN Tx/Rx Buffer 7 */
86 #define SUN4I_REG_BUF8_ADDR 0x0060 /* CAN Tx/Rx Buffer 8 */
87 #define SUN4I_REG_BUF9_ADDR 0x0064 /* CAN Tx/Rx Buffer 9 */
88 #define SUN4I_REG_BUF10_ADDR 0x0068 /* CAN Tx/Rx Buffer 10 */
89 #define SUN4I_REG_BUF11_ADDR 0x006c /* CAN Tx/Rx Buffer 11 */
90 #define SUN4I_REG_BUF12_ADDR 0x0070 /* CAN Tx/Rx Buffer 12 */
91 #define SUN4I_REG_ACPC_ADDR 0x0040 /* CAN Acceptance Code 0 */
92 #define SUN4I_REG_ACPM_ADDR 0x0044 /* CAN Acceptance Mask 0 */
93 #define SUN4I_REG_ACPC_ADDR_D1 0x0028 /* CAN Acceptance Code 0 on the D1 */
94 #define SUN4I_REG_ACPM_ADDR_D1 0x002C /* CAN Acceptance Mask 0 on the D1 */
95 #define SUN4I_REG_RBUF_RBACK_START_ADDR 0x0180 /* CAN transmit buffer start */
96 #define SUN4I_REG_RBUF_RBACK_END_ADDR 0x01b0 /* CAN transmit buffer end */
97
98 /* Controller Register Description */
99
100 /* mode select register (r/w)
101 * offset:0x0000 default:0x0000_0001
102 */
103 #define SUN4I_MSEL_SLEEP_MODE (0x01 << 4) /* write in reset mode */
104 #define SUN4I_MSEL_WAKE_UP (0x00 << 4)
105 #define SUN4I_MSEL_SINGLE_FILTER (0x01 << 3) /* write in reset mode */
106 #define SUN4I_MSEL_DUAL_FILTERS (0x00 << 3)
107 #define SUN4I_MSEL_LOOPBACK_MODE BIT(2)
108 #define SUN4I_MSEL_LISTEN_ONLY_MODE BIT(1)
109 #define SUN4I_MSEL_RESET_MODE BIT(0)
110
111 /* command register (w)
112 * offset:0x0004 default:0x0000_0000
113 */
114 #define SUN4I_CMD_BUS_OFF_REQ BIT(5)
115 #define SUN4I_CMD_SELF_RCV_REQ BIT(4)
116 #define SUN4I_CMD_CLEAR_OR_FLAG BIT(3)
117 #define SUN4I_CMD_RELEASE_RBUF BIT(2)
118 #define SUN4I_CMD_ABORT_REQ BIT(1)
119 #define SUN4I_CMD_TRANS_REQ BIT(0)
120
121 /* status register (r)
122 * offset:0x0008 default:0x0000_003c
123 */
124 #define SUN4I_STA_BIT_ERR (0x00 << 22)
125 #define SUN4I_STA_FORM_ERR (0x01 << 22)
126 #define SUN4I_STA_STUFF_ERR (0x02 << 22)
127 #define SUN4I_STA_OTHER_ERR (0x03 << 22)
128 #define SUN4I_STA_MASK_ERR (0x03 << 22)
129 #define SUN4I_STA_ERR_DIR BIT(21)
130 #define SUN4I_STA_ERR_SEG_CODE (0x1f << 16)
131 #define SUN4I_STA_START (0x03 << 16)
132 #define SUN4I_STA_ID28_21 (0x02 << 16)
133 #define SUN4I_STA_ID20_18 (0x06 << 16)
134 #define SUN4I_STA_SRTR (0x04 << 16)
135 #define SUN4I_STA_IDE (0x05 << 16)
136 #define SUN4I_STA_ID17_13 (0x07 << 16)
137 #define SUN4I_STA_ID12_5 (0x0f << 16)
138 #define SUN4I_STA_ID4_0 (0x0e << 16)
139 #define SUN4I_STA_RTR (0x0c << 16)
140 #define SUN4I_STA_RB1 (0x0d << 16)
141 #define SUN4I_STA_RB0 (0x09 << 16)
142 #define SUN4I_STA_DLEN (0x0b << 16)
143 #define SUN4I_STA_DATA_FIELD (0x0a << 16)
144 #define SUN4I_STA_CRC_SEQUENCE (0x08 << 16)
145 #define SUN4I_STA_CRC_DELIMITER (0x18 << 16)
146 #define SUN4I_STA_ACK (0x19 << 16)
147 #define SUN4I_STA_ACK_DELIMITER (0x1b << 16)
148 #define SUN4I_STA_END (0x1a << 16)
149 #define SUN4I_STA_INTERMISSION (0x12 << 16)
150 #define SUN4I_STA_ACTIVE_ERROR (0x11 << 16)
151 #define SUN4I_STA_PASSIVE_ERROR (0x16 << 16)
152 #define SUN4I_STA_TOLERATE_DOMINANT_BITS (0x13 << 16)
153 #define SUN4I_STA_ERROR_DELIMITER (0x17 << 16)
154 #define SUN4I_STA_OVERLOAD (0x1c << 16)
155 #define SUN4I_STA_BUS_OFF BIT(7)
156 #define SUN4I_STA_ERR_STA BIT(6)
157 #define SUN4I_STA_TRANS_BUSY BIT(5)
158 #define SUN4I_STA_RCV_BUSY BIT(4)
159 #define SUN4I_STA_TRANS_OVER BIT(3)
160 #define SUN4I_STA_TBUF_RDY BIT(2)
161 #define SUN4I_STA_DATA_ORUN BIT(1)
162 #define SUN4I_STA_RBUF_RDY BIT(0)
163
164 /* interrupt register (r)
165 * offset:0x000c default:0x0000_0000
166 */
167 #define SUN4I_INT_BUS_ERR BIT(7)
168 #define SUN4I_INT_ARB_LOST BIT(6)
169 #define SUN4I_INT_ERR_PASSIVE BIT(5)
170 #define SUN4I_INT_WAKEUP BIT(4)
171 #define SUN4I_INT_DATA_OR BIT(3)
172 #define SUN4I_INT_ERR_WRN BIT(2)
173 #define SUN4I_INT_TBUF_VLD BIT(1)
174 #define SUN4I_INT_RBUF_VLD BIT(0)
175
176 /* interrupt enable register (r/w)
177 * offset:0x0010 default:0x0000_0000
178 */
179 #define SUN4I_INTEN_BERR BIT(7)
180 #define SUN4I_INTEN_ARB_LOST BIT(6)
181 #define SUN4I_INTEN_ERR_PASSIVE BIT(5)
182 #define SUN4I_INTEN_WAKEUP BIT(4)
183 #define SUN4I_INTEN_OR BIT(3)
184 #define SUN4I_INTEN_ERR_WRN BIT(2)
185 #define SUN4I_INTEN_TX BIT(1)
186 #define SUN4I_INTEN_RX BIT(0)
187
188 /* error code */
189 #define SUN4I_ERR_INRCV (0x1 << 5)
190 #define SUN4I_ERR_INTRANS (0x0 << 5)
191
192 /* filter mode */
193 #define SUN4I_FILTER_CLOSE 0
194 #define SUN4I_SINGLE_FLTER_MODE 1
195 #define SUN4I_DUAL_FILTER_MODE 2
196
197 /* message buffer flags */
198 #define SUN4I_MSG_EFF_FLAG BIT(7)
199 #define SUN4I_MSG_RTR_FLAG BIT(6)
200
201 /* max. number of interrupts handled in ISR */
202 #define SUN4I_CAN_MAX_IRQ 20
203 #define SUN4I_MODE_MAX_RETRIES 100
204
205 /**
206 * struct sun4ican_quirks - Differences between SoC variants.
207 *
208 * @has_reset: SoC needs reset deasserted.
209 * @acp_offset: Offset of ACPC and ACPM registers
210 */
211 struct sun4ican_quirks {
212 bool has_reset;
213 int acp_offset;
214 };
215
216 struct sun4ican_priv {
217 struct can_priv can;
218 void __iomem *base;
219 struct clk *clk;
220 struct reset_control *reset;
221 spinlock_t cmdreg_lock; /* lock for concurrent cmd register writes */
222 int acp_offset;
223 };
224
225 static const struct can_bittiming_const sun4ican_bittiming_const = {
226 .name = DRV_NAME,
227 .tseg1_min = 1,
228 .tseg1_max = 16,
229 .tseg2_min = 1,
230 .tseg2_max = 8,
231 .sjw_max = 4,
232 .brp_min = 1,
233 .brp_max = 64,
234 .brp_inc = 1,
235 };
236
sun4i_can_write_cmdreg(struct sun4ican_priv * priv,u8 val)237 static void sun4i_can_write_cmdreg(struct sun4ican_priv *priv, u8 val)
238 {
239 unsigned long flags;
240
241 spin_lock_irqsave(&priv->cmdreg_lock, flags);
242 writel(val, priv->base + SUN4I_REG_CMD_ADDR);
243 spin_unlock_irqrestore(&priv->cmdreg_lock, flags);
244 }
245
set_normal_mode(struct net_device * dev)246 static int set_normal_mode(struct net_device *dev)
247 {
248 struct sun4ican_priv *priv = netdev_priv(dev);
249 int retry = SUN4I_MODE_MAX_RETRIES;
250 u32 mod_reg_val = 0;
251
252 do {
253 mod_reg_val = readl(priv->base + SUN4I_REG_MSEL_ADDR);
254 mod_reg_val &= ~SUN4I_MSEL_RESET_MODE;
255 writel(mod_reg_val, priv->base + SUN4I_REG_MSEL_ADDR);
256 } while (retry-- && (mod_reg_val & SUN4I_MSEL_RESET_MODE));
257
258 if (readl(priv->base + SUN4I_REG_MSEL_ADDR) & SUN4I_MSEL_RESET_MODE) {
259 netdev_err(dev,
260 "setting controller into normal mode failed!\n");
261 return -ETIMEDOUT;
262 }
263
264 return 0;
265 }
266
set_reset_mode(struct net_device * dev)267 static int set_reset_mode(struct net_device *dev)
268 {
269 struct sun4ican_priv *priv = netdev_priv(dev);
270 int retry = SUN4I_MODE_MAX_RETRIES;
271 u32 mod_reg_val = 0;
272
273 do {
274 mod_reg_val = readl(priv->base + SUN4I_REG_MSEL_ADDR);
275 mod_reg_val |= SUN4I_MSEL_RESET_MODE;
276 writel(mod_reg_val, priv->base + SUN4I_REG_MSEL_ADDR);
277 } while (retry-- && !(mod_reg_val & SUN4I_MSEL_RESET_MODE));
278
279 if (!(readl(priv->base + SUN4I_REG_MSEL_ADDR) &
280 SUN4I_MSEL_RESET_MODE)) {
281 netdev_err(dev, "setting controller into reset mode failed!\n");
282 return -ETIMEDOUT;
283 }
284
285 return 0;
286 }
287
288 /* bittiming is called in reset_mode only */
sun4ican_set_bittiming(struct net_device * dev)289 static int sun4ican_set_bittiming(struct net_device *dev)
290 {
291 struct sun4ican_priv *priv = netdev_priv(dev);
292 struct can_bittiming *bt = &priv->can.bittiming;
293 u32 cfg;
294
295 cfg = ((bt->brp - 1) & 0x3FF) |
296 (((bt->sjw - 1) & 0x3) << 14) |
297 (((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) << 16) |
298 (((bt->phase_seg2 - 1) & 0x7) << 20);
299 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
300 cfg |= 0x800000;
301
302 netdev_dbg(dev, "setting BITTIMING=0x%08x\n", cfg);
303 writel(cfg, priv->base + SUN4I_REG_BTIME_ADDR);
304
305 return 0;
306 }
307
sun4ican_get_berr_counter(const struct net_device * dev,struct can_berr_counter * bec)308 static int sun4ican_get_berr_counter(const struct net_device *dev,
309 struct can_berr_counter *bec)
310 {
311 struct sun4ican_priv *priv = netdev_priv(dev);
312 u32 errors;
313 int err;
314
315 err = clk_prepare_enable(priv->clk);
316 if (err) {
317 netdev_err(dev, "could not enable clock\n");
318 return err;
319 }
320
321 errors = readl(priv->base + SUN4I_REG_ERRC_ADDR);
322
323 bec->txerr = errors & 0xFF;
324 bec->rxerr = (errors >> 16) & 0xFF;
325
326 clk_disable_unprepare(priv->clk);
327
328 return 0;
329 }
330
sun4i_can_start(struct net_device * dev)331 static int sun4i_can_start(struct net_device *dev)
332 {
333 struct sun4ican_priv *priv = netdev_priv(dev);
334 int err;
335 u32 mod_reg_val;
336
337 /* we need to enter the reset mode */
338 err = set_reset_mode(dev);
339 if (err) {
340 netdev_err(dev, "could not enter reset mode\n");
341 return err;
342 }
343
344 /* set filters - we accept all */
345 writel(0x00000000, priv->base + SUN4I_REG_ACPC_ADDR + priv->acp_offset);
346 writel(0xFFFFFFFF, priv->base + SUN4I_REG_ACPM_ADDR + priv->acp_offset);
347
348 /* clear error counters and error code capture */
349 writel(0, priv->base + SUN4I_REG_ERRC_ADDR);
350
351 /* enable interrupts */
352 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
353 writel(0xFF, priv->base + SUN4I_REG_INTEN_ADDR);
354 else
355 writel(0xFF & ~SUN4I_INTEN_BERR,
356 priv->base + SUN4I_REG_INTEN_ADDR);
357
358 /* enter the selected mode */
359 mod_reg_val = readl(priv->base + SUN4I_REG_MSEL_ADDR);
360 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
361 mod_reg_val |= SUN4I_MSEL_LOOPBACK_MODE;
362 else if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
363 mod_reg_val |= SUN4I_MSEL_LISTEN_ONLY_MODE;
364 writel(mod_reg_val, priv->base + SUN4I_REG_MSEL_ADDR);
365
366 err = sun4ican_set_bittiming(dev);
367 if (err)
368 return err;
369
370 /* we are ready to enter the normal mode */
371 err = set_normal_mode(dev);
372 if (err) {
373 netdev_err(dev, "could not enter normal mode\n");
374 return err;
375 }
376
377 priv->can.state = CAN_STATE_ERROR_ACTIVE;
378
379 return 0;
380 }
381
sun4i_can_stop(struct net_device * dev)382 static int sun4i_can_stop(struct net_device *dev)
383 {
384 struct sun4ican_priv *priv = netdev_priv(dev);
385 int err;
386
387 priv->can.state = CAN_STATE_STOPPED;
388 /* we need to enter reset mode */
389 err = set_reset_mode(dev);
390 if (err) {
391 netdev_err(dev, "could not enter reset mode\n");
392 return err;
393 }
394
395 /* disable all interrupts */
396 writel(0, priv->base + SUN4I_REG_INTEN_ADDR);
397
398 return 0;
399 }
400
sun4ican_set_mode(struct net_device * dev,enum can_mode mode)401 static int sun4ican_set_mode(struct net_device *dev, enum can_mode mode)
402 {
403 int err;
404
405 switch (mode) {
406 case CAN_MODE_START:
407 err = sun4i_can_start(dev);
408 if (err) {
409 netdev_err(dev, "starting CAN controller failed!\n");
410 return err;
411 }
412 if (netif_queue_stopped(dev))
413 netif_wake_queue(dev);
414 break;
415
416 default:
417 return -EOPNOTSUPP;
418 }
419 return 0;
420 }
421
422 /* transmit a CAN message
423 * message layout in the sk_buff should be like this:
424 * xx xx xx xx ff ll 00 11 22 33 44 55 66 77
425 * [ can_id ] [flags] [len] [can data (up to 8 bytes]
426 */
sun4ican_start_xmit(struct sk_buff * skb,struct net_device * dev)427 static netdev_tx_t sun4ican_start_xmit(struct sk_buff *skb, struct net_device *dev)
428 {
429 struct sun4ican_priv *priv = netdev_priv(dev);
430 struct can_frame *cf = (struct can_frame *)skb->data;
431 u8 dlc;
432 u32 dreg, msg_flag_n;
433 canid_t id;
434 int i;
435
436 if (can_dev_dropped_skb(dev, skb))
437 return NETDEV_TX_OK;
438
439 netif_stop_queue(dev);
440
441 id = cf->can_id;
442 dlc = cf->len;
443 msg_flag_n = dlc;
444
445 if (id & CAN_RTR_FLAG)
446 msg_flag_n |= SUN4I_MSG_RTR_FLAG;
447
448 if (id & CAN_EFF_FLAG) {
449 msg_flag_n |= SUN4I_MSG_EFF_FLAG;
450 dreg = SUN4I_REG_BUF5_ADDR;
451 writel((id >> 21) & 0xFF, priv->base + SUN4I_REG_BUF1_ADDR);
452 writel((id >> 13) & 0xFF, priv->base + SUN4I_REG_BUF2_ADDR);
453 writel((id >> 5) & 0xFF, priv->base + SUN4I_REG_BUF3_ADDR);
454 writel((id << 3) & 0xF8, priv->base + SUN4I_REG_BUF4_ADDR);
455 } else {
456 dreg = SUN4I_REG_BUF3_ADDR;
457 writel((id >> 3) & 0xFF, priv->base + SUN4I_REG_BUF1_ADDR);
458 writel((id << 5) & 0xE0, priv->base + SUN4I_REG_BUF2_ADDR);
459 }
460
461 for (i = 0; i < dlc; i++)
462 writel(cf->data[i], priv->base + (dreg + i * 4));
463
464 writel(msg_flag_n, priv->base + SUN4I_REG_BUF0_ADDR);
465
466 can_put_echo_skb(skb, dev, 0, 0);
467
468 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
469 sun4i_can_write_cmdreg(priv, SUN4I_CMD_SELF_RCV_REQ);
470 else
471 sun4i_can_write_cmdreg(priv, SUN4I_CMD_TRANS_REQ);
472
473 return NETDEV_TX_OK;
474 }
475
sun4i_can_rx(struct net_device * dev)476 static void sun4i_can_rx(struct net_device *dev)
477 {
478 struct sun4ican_priv *priv = netdev_priv(dev);
479 struct net_device_stats *stats = &dev->stats;
480 struct can_frame *cf;
481 struct sk_buff *skb;
482 u8 fi;
483 u32 dreg;
484 canid_t id;
485 int i;
486
487 /* create zero'ed CAN frame buffer */
488 skb = alloc_can_skb(dev, &cf);
489 if (!skb)
490 return;
491
492 fi = readl(priv->base + SUN4I_REG_BUF0_ADDR);
493 cf->len = can_cc_dlc2len(fi & 0x0F);
494 if (fi & SUN4I_MSG_EFF_FLAG) {
495 dreg = SUN4I_REG_BUF5_ADDR;
496 id = (readl(priv->base + SUN4I_REG_BUF1_ADDR) << 21) |
497 (readl(priv->base + SUN4I_REG_BUF2_ADDR) << 13) |
498 (readl(priv->base + SUN4I_REG_BUF3_ADDR) << 5) |
499 ((readl(priv->base + SUN4I_REG_BUF4_ADDR) >> 3) & 0x1f);
500 id |= CAN_EFF_FLAG;
501 } else {
502 dreg = SUN4I_REG_BUF3_ADDR;
503 id = (readl(priv->base + SUN4I_REG_BUF1_ADDR) << 3) |
504 ((readl(priv->base + SUN4I_REG_BUF2_ADDR) >> 5) & 0x7);
505 }
506
507 /* remote frame ? */
508 if (fi & SUN4I_MSG_RTR_FLAG) {
509 id |= CAN_RTR_FLAG;
510 } else {
511 for (i = 0; i < cf->len; i++)
512 cf->data[i] = readl(priv->base + dreg + i * 4);
513
514 stats->rx_bytes += cf->len;
515 }
516 stats->rx_packets++;
517
518 cf->can_id = id;
519
520 sun4i_can_write_cmdreg(priv, SUN4I_CMD_RELEASE_RBUF);
521
522 netif_rx(skb);
523 }
524
sun4i_can_err(struct net_device * dev,u8 isrc,u8 status)525 static int sun4i_can_err(struct net_device *dev, u8 isrc, u8 status)
526 {
527 struct sun4ican_priv *priv = netdev_priv(dev);
528 struct net_device_stats *stats = &dev->stats;
529 struct can_frame *cf;
530 struct sk_buff *skb;
531 enum can_state state = priv->can.state;
532 enum can_state rx_state, tx_state;
533 unsigned int rxerr, txerr, errc;
534 u32 ecc, alc;
535
536 /* we don't skip if alloc fails because we want the stats anyhow */
537 skb = alloc_can_err_skb(dev, &cf);
538
539 errc = readl(priv->base + SUN4I_REG_ERRC_ADDR);
540 rxerr = (errc >> 16) & 0xFF;
541 txerr = errc & 0xFF;
542
543 if (isrc & SUN4I_INT_DATA_OR) {
544 /* data overrun interrupt */
545 netdev_dbg(dev, "data overrun interrupt\n");
546 if (likely(skb)) {
547 cf->can_id |= CAN_ERR_CRTL;
548 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
549 }
550 stats->rx_over_errors++;
551 stats->rx_errors++;
552
553 /* reset the CAN IP by entering reset mode
554 * ignoring timeout error
555 */
556 set_reset_mode(dev);
557 set_normal_mode(dev);
558
559 /* clear bit */
560 sun4i_can_write_cmdreg(priv, SUN4I_CMD_CLEAR_OR_FLAG);
561 }
562 if (isrc & SUN4I_INT_ERR_WRN) {
563 /* error warning interrupt */
564 netdev_dbg(dev, "error warning interrupt\n");
565
566 if (status & SUN4I_STA_BUS_OFF)
567 state = CAN_STATE_BUS_OFF;
568 else if (status & SUN4I_STA_ERR_STA)
569 state = CAN_STATE_ERROR_WARNING;
570 else
571 state = CAN_STATE_ERROR_ACTIVE;
572 }
573 if (skb && state != CAN_STATE_BUS_OFF) {
574 cf->can_id |= CAN_ERR_CNT;
575 cf->data[6] = txerr;
576 cf->data[7] = rxerr;
577 }
578 if (isrc & SUN4I_INT_BUS_ERR) {
579 /* bus error interrupt */
580 netdev_dbg(dev, "bus error interrupt\n");
581 priv->can.can_stats.bus_error++;
582 ecc = readl(priv->base + SUN4I_REG_STA_ADDR);
583
584 if (likely(skb)) {
585 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
586
587 switch (ecc & SUN4I_STA_MASK_ERR) {
588 case SUN4I_STA_BIT_ERR:
589 cf->data[2] |= CAN_ERR_PROT_BIT;
590 break;
591 case SUN4I_STA_FORM_ERR:
592 cf->data[2] |= CAN_ERR_PROT_FORM;
593 break;
594 case SUN4I_STA_STUFF_ERR:
595 cf->data[2] |= CAN_ERR_PROT_STUFF;
596 break;
597 default:
598 cf->data[3] = (ecc & SUN4I_STA_ERR_SEG_CODE)
599 >> 16;
600 break;
601 }
602 }
603
604 /* error occurred during transmission? */
605 if ((ecc & SUN4I_STA_ERR_DIR) == 0) {
606 if (likely(skb))
607 cf->data[2] |= CAN_ERR_PROT_TX;
608 stats->tx_errors++;
609 } else {
610 stats->rx_errors++;
611 }
612 }
613 if (isrc & SUN4I_INT_ERR_PASSIVE) {
614 /* error passive interrupt */
615 netdev_dbg(dev, "error passive interrupt\n");
616 if (state == CAN_STATE_ERROR_PASSIVE)
617 state = CAN_STATE_ERROR_WARNING;
618 else
619 state = CAN_STATE_ERROR_PASSIVE;
620 }
621 if (isrc & SUN4I_INT_ARB_LOST) {
622 /* arbitration lost interrupt */
623 netdev_dbg(dev, "arbitration lost interrupt\n");
624 alc = readl(priv->base + SUN4I_REG_STA_ADDR);
625 priv->can.can_stats.arbitration_lost++;
626 if (likely(skb)) {
627 cf->can_id |= CAN_ERR_LOSTARB;
628 cf->data[0] = (alc >> 8) & 0x1f;
629 }
630 }
631
632 if (state != priv->can.state) {
633 tx_state = txerr >= rxerr ? state : 0;
634 rx_state = txerr <= rxerr ? state : 0;
635
636 /* The skb allocation might fail, but can_change_state()
637 * handles cf == NULL.
638 */
639 can_change_state(dev, cf, tx_state, rx_state);
640 if (state == CAN_STATE_BUS_OFF)
641 can_bus_off(dev);
642 }
643
644 if (likely(skb))
645 netif_rx(skb);
646 else
647 return -ENOMEM;
648
649 return 0;
650 }
651
sun4i_can_interrupt(int irq,void * dev_id)652 static irqreturn_t sun4i_can_interrupt(int irq, void *dev_id)
653 {
654 struct net_device *dev = (struct net_device *)dev_id;
655 struct sun4ican_priv *priv = netdev_priv(dev);
656 struct net_device_stats *stats = &dev->stats;
657 u8 isrc, status;
658 int n = 0;
659
660 while ((isrc = readl(priv->base + SUN4I_REG_INT_ADDR)) &&
661 (n < SUN4I_CAN_MAX_IRQ)) {
662 n++;
663 status = readl(priv->base + SUN4I_REG_STA_ADDR);
664
665 if (isrc & SUN4I_INT_WAKEUP)
666 netdev_warn(dev, "wakeup interrupt\n");
667
668 if (isrc & SUN4I_INT_TBUF_VLD) {
669 /* transmission complete interrupt */
670 stats->tx_bytes += can_get_echo_skb(dev, 0, NULL);
671 stats->tx_packets++;
672 netif_wake_queue(dev);
673 }
674 if ((isrc & SUN4I_INT_RBUF_VLD) &&
675 !(isrc & SUN4I_INT_DATA_OR)) {
676 /* receive interrupt - don't read if overrun occurred */
677 while (status & SUN4I_STA_RBUF_RDY) {
678 /* RX buffer is not empty */
679 sun4i_can_rx(dev);
680 status = readl(priv->base + SUN4I_REG_STA_ADDR);
681 }
682 }
683 if (isrc &
684 (SUN4I_INT_DATA_OR | SUN4I_INT_ERR_WRN | SUN4I_INT_BUS_ERR |
685 SUN4I_INT_ERR_PASSIVE | SUN4I_INT_ARB_LOST)) {
686 /* error interrupt */
687 if (sun4i_can_err(dev, isrc, status))
688 netdev_err(dev, "can't allocate buffer - clearing pending interrupts\n");
689 }
690 /* clear interrupts */
691 writel(isrc, priv->base + SUN4I_REG_INT_ADDR);
692 readl(priv->base + SUN4I_REG_INT_ADDR);
693 }
694 if (n >= SUN4I_CAN_MAX_IRQ)
695 netdev_dbg(dev, "%d messages handled in ISR", n);
696
697 return (n) ? IRQ_HANDLED : IRQ_NONE;
698 }
699
sun4ican_open(struct net_device * dev)700 static int sun4ican_open(struct net_device *dev)
701 {
702 struct sun4ican_priv *priv = netdev_priv(dev);
703 int err;
704
705 /* common open */
706 err = open_candev(dev);
707 if (err)
708 return err;
709
710 /* register interrupt handler */
711 err = request_irq(dev->irq, sun4i_can_interrupt, 0, dev->name, dev);
712 if (err) {
713 netdev_err(dev, "request_irq err: %d\n", err);
714 goto exit_irq;
715 }
716
717 /* software reset deassert */
718 err = reset_control_deassert(priv->reset);
719 if (err) {
720 netdev_err(dev, "could not deassert CAN reset\n");
721 goto exit_soft_reset;
722 }
723
724 /* turn on clocking for CAN peripheral block */
725 err = clk_prepare_enable(priv->clk);
726 if (err) {
727 netdev_err(dev, "could not enable CAN peripheral clock\n");
728 goto exit_clock;
729 }
730
731 err = sun4i_can_start(dev);
732 if (err) {
733 netdev_err(dev, "could not start CAN peripheral\n");
734 goto exit_can_start;
735 }
736
737 netif_start_queue(dev);
738
739 return 0;
740
741 exit_can_start:
742 clk_disable_unprepare(priv->clk);
743 exit_clock:
744 reset_control_assert(priv->reset);
745 exit_soft_reset:
746 free_irq(dev->irq, dev);
747 exit_irq:
748 close_candev(dev);
749 return err;
750 }
751
sun4ican_close(struct net_device * dev)752 static int sun4ican_close(struct net_device *dev)
753 {
754 struct sun4ican_priv *priv = netdev_priv(dev);
755
756 netif_stop_queue(dev);
757 sun4i_can_stop(dev);
758 clk_disable_unprepare(priv->clk);
759 reset_control_assert(priv->reset);
760
761 free_irq(dev->irq, dev);
762 close_candev(dev);
763
764 return 0;
765 }
766
767 static const struct net_device_ops sun4ican_netdev_ops = {
768 .ndo_open = sun4ican_open,
769 .ndo_stop = sun4ican_close,
770 .ndo_start_xmit = sun4ican_start_xmit,
771 };
772
773 static const struct ethtool_ops sun4ican_ethtool_ops = {
774 .get_ts_info = ethtool_op_get_ts_info,
775 };
776
777 static const struct sun4ican_quirks sun4ican_quirks_a10 = {
778 .has_reset = false,
779 .acp_offset = 0,
780 };
781
782 static const struct sun4ican_quirks sun4ican_quirks_r40 = {
783 .has_reset = true,
784 .acp_offset = 0,
785 };
786
787 static const struct sun4ican_quirks sun4ican_quirks_d1 = {
788 .has_reset = true,
789 .acp_offset = (SUN4I_REG_ACPC_ADDR_D1 - SUN4I_REG_ACPC_ADDR),
790 };
791
792 static const struct of_device_id sun4ican_of_match[] = {
793 {
794 .compatible = "allwinner,sun4i-a10-can",
795 .data = &sun4ican_quirks_a10
796 }, {
797 .compatible = "allwinner,sun7i-a20-can",
798 .data = &sun4ican_quirks_a10
799 }, {
800 .compatible = "allwinner,sun8i-r40-can",
801 .data = &sun4ican_quirks_r40
802 }, {
803 .compatible = "allwinner,sun20i-d1-can",
804 .data = &sun4ican_quirks_d1
805 }, {
806 /* sentinel */
807 },
808 };
809
810 MODULE_DEVICE_TABLE(of, sun4ican_of_match);
811
sun4ican_remove(struct platform_device * pdev)812 static void sun4ican_remove(struct platform_device *pdev)
813 {
814 struct net_device *dev = platform_get_drvdata(pdev);
815
816 unregister_netdev(dev);
817 free_candev(dev);
818 }
819
sun4ican_probe(struct platform_device * pdev)820 static int sun4ican_probe(struct platform_device *pdev)
821 {
822 struct device_node *np = pdev->dev.of_node;
823 struct clk *clk;
824 struct reset_control *reset = NULL;
825 void __iomem *addr;
826 int err, irq;
827 struct net_device *dev;
828 struct sun4ican_priv *priv;
829 const struct sun4ican_quirks *quirks;
830
831 quirks = of_device_get_match_data(&pdev->dev);
832 if (!quirks) {
833 dev_err(&pdev->dev, "failed to determine the quirks to use\n");
834 err = -ENODEV;
835 goto exit;
836 }
837
838 if (quirks->has_reset) {
839 reset = devm_reset_control_get_exclusive(&pdev->dev, NULL);
840 if (IS_ERR(reset)) {
841 dev_err(&pdev->dev, "unable to request reset\n");
842 err = PTR_ERR(reset);
843 goto exit;
844 }
845 }
846
847 clk = of_clk_get(np, 0);
848 if (IS_ERR(clk)) {
849 dev_err(&pdev->dev, "unable to request clock\n");
850 err = -ENODEV;
851 goto exit;
852 }
853
854 irq = platform_get_irq(pdev, 0);
855 if (irq < 0) {
856 err = -ENODEV;
857 goto exit;
858 }
859
860 addr = devm_platform_ioremap_resource(pdev, 0);
861 if (IS_ERR(addr)) {
862 err = PTR_ERR(addr);
863 goto exit;
864 }
865
866 dev = alloc_candev(sizeof(struct sun4ican_priv), 1);
867 if (!dev) {
868 dev_err(&pdev->dev,
869 "could not allocate memory for CAN device\n");
870 err = -ENOMEM;
871 goto exit;
872 }
873
874 dev->netdev_ops = &sun4ican_netdev_ops;
875 dev->ethtool_ops = &sun4ican_ethtool_ops;
876 dev->irq = irq;
877 dev->flags |= IFF_ECHO;
878
879 priv = netdev_priv(dev);
880 priv->can.clock.freq = clk_get_rate(clk);
881 priv->can.bittiming_const = &sun4ican_bittiming_const;
882 priv->can.do_set_mode = sun4ican_set_mode;
883 priv->can.do_get_berr_counter = sun4ican_get_berr_counter;
884 priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING |
885 CAN_CTRLMODE_LISTENONLY |
886 CAN_CTRLMODE_LOOPBACK |
887 CAN_CTRLMODE_3_SAMPLES;
888 priv->base = addr;
889 priv->clk = clk;
890 priv->reset = reset;
891 priv->acp_offset = quirks->acp_offset;
892 spin_lock_init(&priv->cmdreg_lock);
893
894 platform_set_drvdata(pdev, dev);
895 SET_NETDEV_DEV(dev, &pdev->dev);
896
897 err = register_candev(dev);
898 if (err) {
899 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
900 DRV_NAME, err);
901 goto exit_free;
902 }
903
904 dev_info(&pdev->dev, "device registered (base=%p, irq=%d)\n",
905 priv->base, dev->irq);
906
907 return 0;
908
909 exit_free:
910 free_candev(dev);
911 exit:
912 return err;
913 }
914
915 static struct platform_driver sun4i_can_driver = {
916 .driver = {
917 .name = DRV_NAME,
918 .of_match_table = sun4ican_of_match,
919 },
920 .probe = sun4ican_probe,
921 .remove = sun4ican_remove,
922 };
923
924 module_platform_driver(sun4i_can_driver);
925
926 MODULE_AUTHOR("Peter Chen <xingkongcp@gmail.com>");
927 MODULE_AUTHOR("Gerhard Bertelsmann <info@gerhard-bertelsmann.de>");
928 MODULE_LICENSE("Dual BSD/GPL");
929 MODULE_DESCRIPTION("CAN driver for Allwinner SoCs (A10/A20/D1)");
930