2 * sja1000.c - Philips SJA1000 network device driver
4 * Copyright (c) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33,
5 * 38106 Braunschweig, GERMANY
7 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of Volkswagen nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
22 * Alternatively, provided that this notice is retained in full, this
23 * software may be distributed under the terms of the GNU General
24 * Public License ("GPL") version 2, in which case the provisions of the
25 * GPL apply INSTEAD OF those given above.
27 * The provided data structures and external interfaces from this code
28 * are not restricted to be used by modules with a GPL compatible license.
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
31 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
32 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
33 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
34 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
35 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
36 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
40 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
45 #include <linux/module.h>
46 #include <linux/init.h>
47 #include <linux/kernel.h>
48 #include <linux/sched.h>
49 #include <linux/types.h>
50 #include <linux/fcntl.h>
51 #include <linux/interrupt.h>
52 #include <linux/ptrace.h>
53 #include <linux/string.h>
54 #include <linux/errno.h>
55 #include <linux/netdevice.h>
56 #include <linux/if_arp.h>
57 #include <linux/if_ether.h>
58 #include <linux/skbuff.h>
59 #include <linux/delay.h>
61 #include <linux/can/dev.h>
62 #include <linux/can/error.h>
63 #include <linux/can/led.h>
67 #define DRV_NAME "sja1000"
69 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
70 MODULE_LICENSE("Dual BSD/GPL");
71 MODULE_DESCRIPTION(DRV_NAME
"CAN netdevice driver");
73 static const struct can_bittiming_const sja1000_bittiming_const
= {
85 static void sja1000_write_cmdreg(struct sja1000_priv
*priv
, u8 val
)
90 * The command register needs some locking and time to settle
91 * the write_reg() operation - especially on SMP systems.
93 spin_lock_irqsave(&priv
->cmdreg_lock
, flags
);
94 priv
->write_reg(priv
, SJA1000_CMR
, val
);
95 priv
->read_reg(priv
, SJA1000_SR
);
96 spin_unlock_irqrestore(&priv
->cmdreg_lock
, flags
);
99 static int sja1000_is_absent(struct sja1000_priv
*priv
)
101 return (priv
->read_reg(priv
, SJA1000_MOD
) == 0xFF);
104 static int sja1000_probe_chip(struct net_device
*dev
)
106 struct sja1000_priv
*priv
= netdev_priv(dev
);
108 if (priv
->reg_base
&& sja1000_is_absent(priv
)) {
109 netdev_err(dev
, "probing failed\n");
115 static void set_reset_mode(struct net_device
*dev
)
117 struct sja1000_priv
*priv
= netdev_priv(dev
);
118 unsigned char status
= priv
->read_reg(priv
, SJA1000_MOD
);
121 /* disable interrupts */
122 priv
->write_reg(priv
, SJA1000_IER
, IRQ_OFF
);
124 for (i
= 0; i
< 100; i
++) {
125 /* check reset bit */
126 if (status
& MOD_RM
) {
127 priv
->can
.state
= CAN_STATE_STOPPED
;
132 priv
->write_reg(priv
, SJA1000_MOD
, MOD_RM
);
134 status
= priv
->read_reg(priv
, SJA1000_MOD
);
137 netdev_err(dev
, "setting SJA1000 into reset mode failed!\n");
140 static void set_normal_mode(struct net_device
*dev
)
142 struct sja1000_priv
*priv
= netdev_priv(dev
);
143 unsigned char status
= priv
->read_reg(priv
, SJA1000_MOD
);
144 u8 mod_reg_val
= 0x00;
147 for (i
= 0; i
< 100; i
++) {
148 /* check reset bit */
149 if ((status
& MOD_RM
) == 0) {
150 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
151 /* enable interrupts */
152 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_BERR_REPORTING
)
153 priv
->write_reg(priv
, SJA1000_IER
, IRQ_ALL
);
155 priv
->write_reg(priv
, SJA1000_IER
,
160 /* set chip to normal mode */
161 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
162 mod_reg_val
|= MOD_LOM
;
163 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_PRESUME_ACK
)
164 mod_reg_val
|= MOD_STM
;
165 priv
->write_reg(priv
, SJA1000_MOD
, mod_reg_val
);
169 status
= priv
->read_reg(priv
, SJA1000_MOD
);
172 netdev_err(dev
, "setting SJA1000 into normal mode failed!\n");
176 * initialize SJA1000 chip:
180 * - enable interrupts
181 * - start operating mode
183 static void chipset_init(struct net_device
*dev
)
185 struct sja1000_priv
*priv
= netdev_priv(dev
);
187 /* set clock divider and output control register */
188 priv
->write_reg(priv
, SJA1000_CDR
, priv
->cdr
| CDR_PELICAN
);
190 /* set acceptance filter (accept all) */
191 priv
->write_reg(priv
, SJA1000_ACCC0
, 0x00);
192 priv
->write_reg(priv
, SJA1000_ACCC1
, 0x00);
193 priv
->write_reg(priv
, SJA1000_ACCC2
, 0x00);
194 priv
->write_reg(priv
, SJA1000_ACCC3
, 0x00);
196 priv
->write_reg(priv
, SJA1000_ACCM0
, 0xFF);
197 priv
->write_reg(priv
, SJA1000_ACCM1
, 0xFF);
198 priv
->write_reg(priv
, SJA1000_ACCM2
, 0xFF);
199 priv
->write_reg(priv
, SJA1000_ACCM3
, 0xFF);
201 priv
->write_reg(priv
, SJA1000_OCR
, priv
->ocr
| OCR_MODE_NORMAL
);
204 static void sja1000_start(struct net_device
*dev
)
206 struct sja1000_priv
*priv
= netdev_priv(dev
);
208 /* leave reset mode */
209 if (priv
->can
.state
!= CAN_STATE_STOPPED
)
212 /* Initialize chip if uninitialized at this stage */
213 if (!(priv
->read_reg(priv
, SJA1000_CDR
) & CDR_PELICAN
))
216 /* Clear error counters and error code capture */
217 priv
->write_reg(priv
, SJA1000_TXERR
, 0x0);
218 priv
->write_reg(priv
, SJA1000_RXERR
, 0x0);
219 priv
->read_reg(priv
, SJA1000_ECC
);
221 /* leave reset mode */
222 set_normal_mode(dev
);
225 static int sja1000_set_mode(struct net_device
*dev
, enum can_mode mode
)
230 if (netif_queue_stopped(dev
))
231 netif_wake_queue(dev
);
241 static int sja1000_set_bittiming(struct net_device
*dev
)
243 struct sja1000_priv
*priv
= netdev_priv(dev
);
244 struct can_bittiming
*bt
= &priv
->can
.bittiming
;
247 btr0
= ((bt
->brp
- 1) & 0x3f) | (((bt
->sjw
- 1) & 0x3) << 6);
248 btr1
= ((bt
->prop_seg
+ bt
->phase_seg1
- 1) & 0xf) |
249 (((bt
->phase_seg2
- 1) & 0x7) << 4);
250 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
253 netdev_info(dev
, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0
, btr1
);
255 priv
->write_reg(priv
, SJA1000_BTR0
, btr0
);
256 priv
->write_reg(priv
, SJA1000_BTR1
, btr1
);
261 static int sja1000_get_berr_counter(const struct net_device
*dev
,
262 struct can_berr_counter
*bec
)
264 struct sja1000_priv
*priv
= netdev_priv(dev
);
266 bec
->txerr
= priv
->read_reg(priv
, SJA1000_TXERR
);
267 bec
->rxerr
= priv
->read_reg(priv
, SJA1000_RXERR
);
273 * transmit a CAN message
274 * message layout in the sk_buff should be like this:
275 * xx xx xx xx ff ll 00 11 22 33 44 55 66 77
276 * [ can-id ] [flags] [len] [can data (up to 8 bytes]
278 static netdev_tx_t
sja1000_start_xmit(struct sk_buff
*skb
,
279 struct net_device
*dev
)
281 struct sja1000_priv
*priv
= netdev_priv(dev
);
282 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
287 u8 cmd_reg_val
= 0x00;
290 if (can_dropped_invalid_skb(dev
, skb
))
293 netif_stop_queue(dev
);
295 fi
= dlc
= cf
->can_dlc
;
298 if (id
& CAN_RTR_FLAG
)
299 fi
|= SJA1000_FI_RTR
;
301 if (id
& CAN_EFF_FLAG
) {
303 dreg
= SJA1000_EFF_BUF
;
304 priv
->write_reg(priv
, SJA1000_FI
, fi
);
305 priv
->write_reg(priv
, SJA1000_ID1
, (id
& 0x1fe00000) >> 21);
306 priv
->write_reg(priv
, SJA1000_ID2
, (id
& 0x001fe000) >> 13);
307 priv
->write_reg(priv
, SJA1000_ID3
, (id
& 0x00001fe0) >> 5);
308 priv
->write_reg(priv
, SJA1000_ID4
, (id
& 0x0000001f) << 3);
310 dreg
= SJA1000_SFF_BUF
;
311 priv
->write_reg(priv
, SJA1000_FI
, fi
);
312 priv
->write_reg(priv
, SJA1000_ID1
, (id
& 0x000007f8) >> 3);
313 priv
->write_reg(priv
, SJA1000_ID2
, (id
& 0x00000007) << 5);
316 for (i
= 0; i
< dlc
; i
++)
317 priv
->write_reg(priv
, dreg
++, cf
->data
[i
]);
319 can_put_echo_skb(skb
, dev
, 0);
321 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_ONE_SHOT
)
322 cmd_reg_val
|= CMD_AT
;
324 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LOOPBACK
)
325 cmd_reg_val
|= CMD_SRR
;
327 cmd_reg_val
|= CMD_TR
;
329 sja1000_write_cmdreg(priv
, cmd_reg_val
);
334 static void sja1000_rx(struct net_device
*dev
)
336 struct sja1000_priv
*priv
= netdev_priv(dev
);
337 struct net_device_stats
*stats
= &dev
->stats
;
338 struct can_frame
*cf
;
345 /* create zero'ed CAN frame buffer */
346 skb
= alloc_can_skb(dev
, &cf
);
350 fi
= priv
->read_reg(priv
, SJA1000_FI
);
352 if (fi
& SJA1000_FI_FF
) {
353 /* extended frame format (EFF) */
354 dreg
= SJA1000_EFF_BUF
;
355 id
= (priv
->read_reg(priv
, SJA1000_ID1
) << 21)
356 | (priv
->read_reg(priv
, SJA1000_ID2
) << 13)
357 | (priv
->read_reg(priv
, SJA1000_ID3
) << 5)
358 | (priv
->read_reg(priv
, SJA1000_ID4
) >> 3);
361 /* standard frame format (SFF) */
362 dreg
= SJA1000_SFF_BUF
;
363 id
= (priv
->read_reg(priv
, SJA1000_ID1
) << 3)
364 | (priv
->read_reg(priv
, SJA1000_ID2
) >> 5);
367 cf
->can_dlc
= get_can_dlc(fi
& 0x0F);
368 if (fi
& SJA1000_FI_RTR
) {
371 for (i
= 0; i
< cf
->can_dlc
; i
++)
372 cf
->data
[i
] = priv
->read_reg(priv
, dreg
++);
377 /* release receive buffer */
378 sja1000_write_cmdreg(priv
, CMD_RRB
);
383 stats
->rx_bytes
+= cf
->can_dlc
;
385 can_led_event(dev
, CAN_LED_EVENT_RX
);
388 static int sja1000_err(struct net_device
*dev
, uint8_t isrc
, uint8_t status
)
390 struct sja1000_priv
*priv
= netdev_priv(dev
);
391 struct net_device_stats
*stats
= &dev
->stats
;
392 struct can_frame
*cf
;
394 enum can_state state
= priv
->can
.state
;
395 enum can_state rx_state
, tx_state
;
396 unsigned int rxerr
, txerr
;
399 skb
= alloc_can_err_skb(dev
, &cf
);
403 txerr
= priv
->read_reg(priv
, SJA1000_TXERR
);
404 rxerr
= priv
->read_reg(priv
, SJA1000_RXERR
);
409 if (isrc
& IRQ_DOI
) {
410 /* data overrun interrupt */
411 netdev_dbg(dev
, "data overrun interrupt\n");
412 cf
->can_id
|= CAN_ERR_CRTL
;
413 cf
->data
[1] = CAN_ERR_CRTL_RX_OVERFLOW
;
414 stats
->rx_over_errors
++;
416 sja1000_write_cmdreg(priv
, CMD_CDO
); /* clear bit */
420 /* error warning interrupt */
421 netdev_dbg(dev
, "error warning interrupt\n");
424 state
= CAN_STATE_BUS_OFF
;
425 else if (status
& SR_ES
)
426 state
= CAN_STATE_ERROR_WARNING
;
428 state
= CAN_STATE_ERROR_ACTIVE
;
430 if (isrc
& IRQ_BEI
) {
431 /* bus error interrupt */
432 priv
->can
.can_stats
.bus_error
++;
435 ecc
= priv
->read_reg(priv
, SJA1000_ECC
);
437 cf
->can_id
|= CAN_ERR_PROT
| CAN_ERR_BUSERROR
;
439 switch (ecc
& ECC_MASK
) {
441 cf
->data
[2] |= CAN_ERR_PROT_BIT
;
444 cf
->data
[2] |= CAN_ERR_PROT_FORM
;
447 cf
->data
[2] |= CAN_ERR_PROT_STUFF
;
450 cf
->data
[2] |= CAN_ERR_PROT_UNSPEC
;
451 cf
->data
[3] = ecc
& ECC_SEG
;
454 /* Error occurred during transmission? */
455 if ((ecc
& ECC_DIR
) == 0)
456 cf
->data
[2] |= CAN_ERR_PROT_TX
;
458 if (isrc
& IRQ_EPI
) {
459 /* error passive interrupt */
460 netdev_dbg(dev
, "error passive interrupt\n");
462 if (state
== CAN_STATE_ERROR_PASSIVE
)
463 state
= CAN_STATE_ERROR_WARNING
;
465 state
= CAN_STATE_ERROR_PASSIVE
;
467 if (isrc
& IRQ_ALI
) {
468 /* arbitration lost interrupt */
469 netdev_dbg(dev
, "arbitration lost interrupt\n");
470 alc
= priv
->read_reg(priv
, SJA1000_ALC
);
471 priv
->can
.can_stats
.arbitration_lost
++;
473 cf
->can_id
|= CAN_ERR_LOSTARB
;
474 cf
->data
[0] = alc
& 0x1f;
477 if (state
!= priv
->can
.state
) {
478 tx_state
= txerr
>= rxerr
? state
: 0;
479 rx_state
= txerr
<= rxerr
? state
: 0;
481 can_change_state(dev
, cf
, tx_state
, rx_state
);
483 if(state
== CAN_STATE_BUS_OFF
)
490 stats
->rx_bytes
+= cf
->can_dlc
;
495 irqreturn_t
sja1000_interrupt(int irq
, void *dev_id
)
497 struct net_device
*dev
= (struct net_device
*)dev_id
;
498 struct sja1000_priv
*priv
= netdev_priv(dev
);
499 struct net_device_stats
*stats
= &dev
->stats
;
500 uint8_t isrc
, status
;
506 /* Shared interrupts and IRQ off? */
507 if (priv
->read_reg(priv
, SJA1000_IER
) == IRQ_OFF
)
510 while ((isrc
= priv
->read_reg(priv
, SJA1000_IR
)) &&
511 (n
< SJA1000_MAX_IRQ
)) {
513 status
= priv
->read_reg(priv
, SJA1000_SR
);
514 /* check for absent controller due to hw unplug */
515 if (status
== 0xFF && sja1000_is_absent(priv
))
519 netdev_warn(dev
, "wakeup interrupt\n");
522 /* transmission buffer released */
523 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_ONE_SHOT
&&
524 !(status
& SR_TCS
)) {
526 can_free_echo_skb(dev
, 0);
528 /* transmission complete */
530 priv
->read_reg(priv
, SJA1000_FI
) & 0xf;
532 can_get_echo_skb(dev
, 0);
534 netif_wake_queue(dev
);
535 can_led_event(dev
, CAN_LED_EVENT_TX
);
538 /* receive interrupt */
539 while (status
& SR_RBS
) {
541 status
= priv
->read_reg(priv
, SJA1000_SR
);
542 /* check for absent controller */
543 if (status
== 0xFF && sja1000_is_absent(priv
))
547 if (isrc
& (IRQ_DOI
| IRQ_EI
| IRQ_BEI
| IRQ_EPI
| IRQ_ALI
)) {
548 /* error interrupt */
549 if (sja1000_err(dev
, isrc
, status
))
556 priv
->post_irq(priv
);
558 if (n
>= SJA1000_MAX_IRQ
)
559 netdev_dbg(dev
, "%d messages handled in ISR", n
);
561 return (n
) ? IRQ_HANDLED
: IRQ_NONE
;
563 EXPORT_SYMBOL_GPL(sja1000_interrupt
);
565 static int sja1000_open(struct net_device
*dev
)
567 struct sja1000_priv
*priv
= netdev_priv(dev
);
570 /* set chip into reset mode */
574 err
= open_candev(dev
);
578 /* register interrupt handler, if not done by the device driver */
579 if (!(priv
->flags
& SJA1000_CUSTOM_IRQ_HANDLER
)) {
580 err
= request_irq(dev
->irq
, sja1000_interrupt
, priv
->irq_flags
,
581 dev
->name
, (void *)dev
);
588 /* init and start chi */
591 can_led_event(dev
, CAN_LED_EVENT_OPEN
);
593 netif_start_queue(dev
);
598 static int sja1000_close(struct net_device
*dev
)
600 struct sja1000_priv
*priv
= netdev_priv(dev
);
602 netif_stop_queue(dev
);
605 if (!(priv
->flags
& SJA1000_CUSTOM_IRQ_HANDLER
))
606 free_irq(dev
->irq
, (void *)dev
);
610 can_led_event(dev
, CAN_LED_EVENT_STOP
);
615 struct net_device
*alloc_sja1000dev(int sizeof_priv
)
617 struct net_device
*dev
;
618 struct sja1000_priv
*priv
;
620 dev
= alloc_candev(sizeof(struct sja1000_priv
) + sizeof_priv
,
621 SJA1000_ECHO_SKB_MAX
);
625 priv
= netdev_priv(dev
);
628 priv
->can
.bittiming_const
= &sja1000_bittiming_const
;
629 priv
->can
.do_set_bittiming
= sja1000_set_bittiming
;
630 priv
->can
.do_set_mode
= sja1000_set_mode
;
631 priv
->can
.do_get_berr_counter
= sja1000_get_berr_counter
;
632 priv
->can
.ctrlmode_supported
= CAN_CTRLMODE_LOOPBACK
|
633 CAN_CTRLMODE_LISTENONLY
|
634 CAN_CTRLMODE_3_SAMPLES
|
635 CAN_CTRLMODE_ONE_SHOT
|
636 CAN_CTRLMODE_BERR_REPORTING
|
637 CAN_CTRLMODE_PRESUME_ACK
;
639 spin_lock_init(&priv
->cmdreg_lock
);
642 priv
->priv
= (void *)priv
+ sizeof(struct sja1000_priv
);
646 EXPORT_SYMBOL_GPL(alloc_sja1000dev
);
648 void free_sja1000dev(struct net_device
*dev
)
652 EXPORT_SYMBOL_GPL(free_sja1000dev
);
654 static const struct net_device_ops sja1000_netdev_ops
= {
655 .ndo_open
= sja1000_open
,
656 .ndo_stop
= sja1000_close
,
657 .ndo_start_xmit
= sja1000_start_xmit
,
658 .ndo_change_mtu
= can_change_mtu
,
661 int register_sja1000dev(struct net_device
*dev
)
665 if (!sja1000_probe_chip(dev
))
668 dev
->flags
|= IFF_ECHO
; /* we support local echo */
669 dev
->netdev_ops
= &sja1000_netdev_ops
;
674 ret
= register_candev(dev
);
677 devm_can_led_init(dev
);
681 EXPORT_SYMBOL_GPL(register_sja1000dev
);
683 void unregister_sja1000dev(struct net_device
*dev
)
686 unregister_candev(dev
);
688 EXPORT_SYMBOL_GPL(unregister_sja1000dev
);
690 static __init
int sja1000_init(void)
692 printk(KERN_INFO
"%s CAN netdevice driver\n", DRV_NAME
);
697 module_init(sja1000_init
);
699 static __exit
void sja1000_exit(void)
701 printk(KERN_INFO
"%s: driver removed\n", DRV_NAME
);
704 module_exit(sja1000_exit
);