1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47#include <linux/module.h>
48#include <linux/init.h>
49#include <linux/kernel.h>
50#include <linux/sched.h>
51#include <linux/types.h>
52#include <linux/fcntl.h>
53#include <linux/interrupt.h>
54#include <linux/ptrace.h>
55#include <linux/string.h>
56#include <linux/errno.h>
57#include <linux/netdevice.h>
58#include <linux/if_arp.h>
59#include <linux/if_ether.h>
60#include <linux/skbuff.h>
61#include <linux/delay.h>
62
63#include <linux/can.h>
64#include <linux/can/dev.h>
65#include <linux/can/error.h>
66
67#include "sja1000.h"
68
69#define DRV_NAME "sja1000"
70
71MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
72MODULE_LICENSE("Dual BSD/GPL");
73MODULE_DESCRIPTION(DRV_NAME "CAN netdevice driver");
74
75static struct can_bittiming_const sja1000_bittiming_const = {
76 .name = DRV_NAME,
77 .tseg1_min = 1,
78 .tseg1_max = 16,
79 .tseg2_min = 1,
80 .tseg2_max = 8,
81 .sjw_max = 4,
82 .brp_min = 1,
83 .brp_max = 64,
84 .brp_inc = 1,
85};
86
87static int sja1000_probe_chip(struct net_device *dev)
88{
89 struct sja1000_priv *priv = netdev_priv(dev);
90
91 if (priv->reg_base && (priv->read_reg(priv, 0) == 0xFF)) {
92 printk(KERN_INFO "%s: probing @0x%lX failed\n",
93 DRV_NAME, dev->base_addr);
94 return 0;
95 }
96 return -1;
97}
98
99static void set_reset_mode(struct net_device *dev)
100{
101 struct sja1000_priv *priv = netdev_priv(dev);
102 unsigned char status = priv->read_reg(priv, REG_MOD);
103 int i;
104
105
106 priv->write_reg(priv, REG_IER, IRQ_OFF);
107
108 for (i = 0; i < 100; i++) {
109
110 if (status & MOD_RM) {
111 priv->can.state = CAN_STATE_STOPPED;
112 return;
113 }
114
115 priv->write_reg(priv, REG_MOD, MOD_RM);
116 udelay(10);
117 status = priv->read_reg(priv, REG_MOD);
118 }
119
120 dev_err(dev->dev.parent, "setting SJA1000 into reset mode failed!\n");
121}
122
123static void set_normal_mode(struct net_device *dev)
124{
125 struct sja1000_priv *priv = netdev_priv(dev);
126 unsigned char status = priv->read_reg(priv, REG_MOD);
127 int i;
128
129 for (i = 0; i < 100; i++) {
130
131 if ((status & MOD_RM) == 0) {
132 priv->can.state = CAN_STATE_ERROR_ACTIVE;
133
134 priv->write_reg(priv, REG_IER, IRQ_ALL);
135 return;
136 }
137
138
139 priv->write_reg(priv, REG_MOD, 0x00);
140 udelay(10);
141 status = priv->read_reg(priv, REG_MOD);
142 }
143
144 dev_err(dev->dev.parent, "setting SJA1000 into normal mode failed!\n");
145}
146
147static void sja1000_start(struct net_device *dev)
148{
149 struct sja1000_priv *priv = netdev_priv(dev);
150
151
152 if (priv->can.state != CAN_STATE_STOPPED)
153 set_reset_mode(dev);
154
155
156 priv->write_reg(priv, REG_TXERR, 0x0);
157 priv->write_reg(priv, REG_RXERR, 0x0);
158 priv->read_reg(priv, REG_ECC);
159
160
161 set_normal_mode(dev);
162}
163
164static int sja1000_set_mode(struct net_device *dev, enum can_mode mode)
165{
166 struct sja1000_priv *priv = netdev_priv(dev);
167
168 if (!priv->open_time)
169 return -EINVAL;
170
171 switch (mode) {
172 case CAN_MODE_START:
173 sja1000_start(dev);
174 if (netif_queue_stopped(dev))
175 netif_wake_queue(dev);
176 break;
177
178 default:
179 return -EOPNOTSUPP;
180 }
181
182 return 0;
183}
184
185static int sja1000_set_bittiming(struct net_device *dev)
186{
187 struct sja1000_priv *priv = netdev_priv(dev);
188 struct can_bittiming *bt = &priv->can.bittiming;
189 u8 btr0, btr1;
190
191 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
192 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
193 (((bt->phase_seg2 - 1) & 0x7) << 4);
194 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
195 btr1 |= 0x80;
196
197 dev_info(dev->dev.parent,
198 "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
199
200 priv->write_reg(priv, REG_BTR0, btr0);
201 priv->write_reg(priv, REG_BTR1, btr1);
202
203 return 0;
204}
205
206
207
208
209
210
211
212
213
214static void chipset_init(struct net_device *dev)
215{
216 struct sja1000_priv *priv = netdev_priv(dev);
217
218
219 priv->write_reg(priv, REG_CDR, priv->cdr | CDR_PELICAN);
220
221
222 priv->write_reg(priv, REG_ACCC0, 0x00);
223 priv->write_reg(priv, REG_ACCC1, 0x00);
224 priv->write_reg(priv, REG_ACCC2, 0x00);
225 priv->write_reg(priv, REG_ACCC3, 0x00);
226
227 priv->write_reg(priv, REG_ACCM0, 0xFF);
228 priv->write_reg(priv, REG_ACCM1, 0xFF);
229 priv->write_reg(priv, REG_ACCM2, 0xFF);
230 priv->write_reg(priv, REG_ACCM3, 0xFF);
231
232 priv->write_reg(priv, REG_OCR, priv->ocr | OCR_MODE_NORMAL);
233}
234
235
236
237
238
239
240
241static netdev_tx_t sja1000_start_xmit(struct sk_buff *skb,
242 struct net_device *dev)
243{
244 struct sja1000_priv *priv = netdev_priv(dev);
245 struct can_frame *cf = (struct can_frame *)skb->data;
246 uint8_t fi;
247 uint8_t dlc;
248 canid_t id;
249 uint8_t dreg;
250 int i;
251
252 netif_stop_queue(dev);
253
254 fi = dlc = cf->can_dlc;
255 id = cf->can_id;
256
257 if (id & CAN_RTR_FLAG)
258 fi |= FI_RTR;
259
260 if (id & CAN_EFF_FLAG) {
261 fi |= FI_FF;
262 dreg = EFF_BUF;
263 priv->write_reg(priv, REG_FI, fi);
264 priv->write_reg(priv, REG_ID1, (id & 0x1fe00000) >> (5 + 16));
265 priv->write_reg(priv, REG_ID2, (id & 0x001fe000) >> (5 + 8));
266 priv->write_reg(priv, REG_ID3, (id & 0x00001fe0) >> 5);
267 priv->write_reg(priv, REG_ID4, (id & 0x0000001f) << 3);
268 } else {
269 dreg = SFF_BUF;
270 priv->write_reg(priv, REG_FI, fi);
271 priv->write_reg(priv, REG_ID1, (id & 0x000007f8) >> 3);
272 priv->write_reg(priv, REG_ID2, (id & 0x00000007) << 5);
273 }
274
275 for (i = 0; i < dlc; i++)
276 priv->write_reg(priv, dreg++, cf->data[i]);
277
278 dev->trans_start = jiffies;
279
280 can_put_echo_skb(skb, dev, 0);
281
282 priv->write_reg(priv, REG_CMR, CMD_TR);
283
284 return NETDEV_TX_OK;
285}
286
287static void sja1000_rx(struct net_device *dev)
288{
289 struct sja1000_priv *priv = netdev_priv(dev);
290 struct net_device_stats *stats = &dev->stats;
291 struct can_frame *cf;
292 struct sk_buff *skb;
293 uint8_t fi;
294 uint8_t dreg;
295 canid_t id;
296 uint8_t dlc;
297 int i;
298
299 skb = dev_alloc_skb(sizeof(struct can_frame));
300 if (skb == NULL)
301 return;
302 skb->dev = dev;
303 skb->protocol = htons(ETH_P_CAN);
304
305 fi = priv->read_reg(priv, REG_FI);
306 dlc = fi & 0x0F;
307
308 if (fi & FI_FF) {
309
310 dreg = EFF_BUF;
311 id = (priv->read_reg(priv, REG_ID1) << (5 + 16))
312 | (priv->read_reg(priv, REG_ID2) << (5 + 8))
313 | (priv->read_reg(priv, REG_ID3) << 5)
314 | (priv->read_reg(priv, REG_ID4) >> 3);
315 id |= CAN_EFF_FLAG;
316 } else {
317
318 dreg = SFF_BUF;
319 id = (priv->read_reg(priv, REG_ID1) << 3)
320 | (priv->read_reg(priv, REG_ID2) >> 5);
321 }
322
323 if (fi & FI_RTR)
324 id |= CAN_RTR_FLAG;
325
326 cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
327 memset(cf, 0, sizeof(struct can_frame));
328 cf->can_id = id;
329 cf->can_dlc = dlc;
330 for (i = 0; i < dlc; i++)
331 cf->data[i] = priv->read_reg(priv, dreg++);
332
333 while (i < 8)
334 cf->data[i++] = 0;
335
336
337 priv->write_reg(priv, REG_CMR, CMD_RRB);
338
339 netif_rx(skb);
340
341 stats->rx_packets++;
342 stats->rx_bytes += dlc;
343}
344
345static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
346{
347 struct sja1000_priv *priv = netdev_priv(dev);
348 struct net_device_stats *stats = &dev->stats;
349 struct can_frame *cf;
350 struct sk_buff *skb;
351 enum can_state state = priv->can.state;
352 uint8_t ecc, alc;
353
354 skb = dev_alloc_skb(sizeof(struct can_frame));
355 if (skb == NULL)
356 return -ENOMEM;
357 skb->dev = dev;
358 skb->protocol = htons(ETH_P_CAN);
359 cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
360 memset(cf, 0, sizeof(struct can_frame));
361 cf->can_id = CAN_ERR_FLAG;
362 cf->can_dlc = CAN_ERR_DLC;
363
364 if (isrc & IRQ_DOI) {
365
366 dev_dbg(dev->dev.parent, "data overrun interrupt\n");
367 cf->can_id |= CAN_ERR_CRTL;
368 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
369 stats->rx_over_errors++;
370 stats->rx_errors++;
371 priv->write_reg(priv, REG_CMR, CMD_CDO);
372 }
373
374 if (isrc & IRQ_EI) {
375
376 dev_dbg(dev->dev.parent, "error warning interrupt\n");
377
378 if (status & SR_BS) {
379 state = CAN_STATE_BUS_OFF;
380 cf->can_id |= CAN_ERR_BUSOFF;
381 can_bus_off(dev);
382 } else if (status & SR_ES) {
383 state = CAN_STATE_ERROR_WARNING;
384 } else
385 state = CAN_STATE_ERROR_ACTIVE;
386 }
387 if (isrc & IRQ_BEI) {
388
389 priv->can.can_stats.bus_error++;
390 stats->rx_errors++;
391
392 ecc = priv->read_reg(priv, REG_ECC);
393
394 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
395
396 switch (ecc & ECC_MASK) {
397 case ECC_BIT:
398 cf->data[2] |= CAN_ERR_PROT_BIT;
399 break;
400 case ECC_FORM:
401 cf->data[2] |= CAN_ERR_PROT_FORM;
402 break;
403 case ECC_STUFF:
404 cf->data[2] |= CAN_ERR_PROT_STUFF;
405 break;
406 default:
407 cf->data[2] |= CAN_ERR_PROT_UNSPEC;
408 cf->data[3] = ecc & ECC_SEG;
409 break;
410 }
411
412 if ((ecc & ECC_DIR) == 0)
413 cf->data[2] |= CAN_ERR_PROT_TX;
414 }
415 if (isrc & IRQ_EPI) {
416
417 dev_dbg(dev->dev.parent, "error passive interrupt\n");
418 if (status & SR_ES)
419 state = CAN_STATE_ERROR_PASSIVE;
420 else
421 state = CAN_STATE_ERROR_ACTIVE;
422 }
423 if (isrc & IRQ_ALI) {
424
425 dev_dbg(dev->dev.parent, "arbitration lost interrupt\n");
426 alc = priv->read_reg(priv, REG_ALC);
427 priv->can.can_stats.arbitration_lost++;
428 stats->tx_errors++;
429 cf->can_id |= CAN_ERR_LOSTARB;
430 cf->data[0] = alc & 0x1f;
431 }
432
433 if (state != priv->can.state && (state == CAN_STATE_ERROR_WARNING ||
434 state == CAN_STATE_ERROR_PASSIVE)) {
435 uint8_t rxerr = priv->read_reg(priv, REG_RXERR);
436 uint8_t txerr = priv->read_reg(priv, REG_TXERR);
437 cf->can_id |= CAN_ERR_CRTL;
438 if (state == CAN_STATE_ERROR_WARNING) {
439 priv->can.can_stats.error_warning++;
440 cf->data[1] = (txerr > rxerr) ?
441 CAN_ERR_CRTL_TX_WARNING :
442 CAN_ERR_CRTL_RX_WARNING;
443 } else {
444 priv->can.can_stats.error_passive++;
445 cf->data[1] = (txerr > rxerr) ?
446 CAN_ERR_CRTL_TX_PASSIVE :
447 CAN_ERR_CRTL_RX_PASSIVE;
448 }
449 }
450
451 priv->can.state = state;
452
453 netif_rx(skb);
454
455 stats->rx_packets++;
456 stats->rx_bytes += cf->can_dlc;
457
458 return 0;
459}
460
461irqreturn_t sja1000_interrupt(int irq, void *dev_id)
462{
463 struct net_device *dev = (struct net_device *)dev_id;
464 struct sja1000_priv *priv = netdev_priv(dev);
465 struct net_device_stats *stats = &dev->stats;
466 uint8_t isrc, status;
467 int n = 0;
468
469
470 if (priv->read_reg(priv, REG_IER) == IRQ_OFF)
471 return IRQ_NONE;
472
473 if (priv->pre_irq)
474 priv->pre_irq(priv);
475
476 while ((isrc = priv->read_reg(priv, REG_IR)) && (n < SJA1000_MAX_IRQ)) {
477 n++;
478 status = priv->read_reg(priv, REG_SR);
479
480 if (isrc & IRQ_WUI)
481 dev_warn(dev->dev.parent, "wakeup interrupt\n");
482
483 if (isrc & IRQ_TI) {
484
485 stats->tx_bytes += priv->read_reg(priv, REG_FI) & 0xf;
486 stats->tx_packets++;
487 can_get_echo_skb(dev, 0);
488 netif_wake_queue(dev);
489 }
490 if (isrc & IRQ_RI) {
491
492 while (status & SR_RBS) {
493 sja1000_rx(dev);
494 status = priv->read_reg(priv, REG_SR);
495 }
496 }
497 if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) {
498
499 if (sja1000_err(dev, isrc, status))
500 break;
501 }
502 }
503
504 if (priv->post_irq)
505 priv->post_irq(priv);
506
507 if (n >= SJA1000_MAX_IRQ)
508 dev_dbg(dev->dev.parent, "%d messages handled in ISR", n);
509
510 return (n) ? IRQ_HANDLED : IRQ_NONE;
511}
512EXPORT_SYMBOL_GPL(sja1000_interrupt);
513
514static int sja1000_open(struct net_device *dev)
515{
516 struct sja1000_priv *priv = netdev_priv(dev);
517 int err;
518
519
520 set_reset_mode(dev);
521
522
523 err = open_candev(dev);
524 if (err)
525 return err;
526
527
528 if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER)) {
529 err = request_irq(dev->irq, &sja1000_interrupt, priv->irq_flags,
530 dev->name, (void *)dev);
531 if (err) {
532 close_candev(dev);
533 return -EAGAIN;
534 }
535 }
536
537
538 sja1000_start(dev);
539 priv->open_time = jiffies;
540
541 netif_start_queue(dev);
542
543 return 0;
544}
545
546static int sja1000_close(struct net_device *dev)
547{
548 struct sja1000_priv *priv = netdev_priv(dev);
549
550 netif_stop_queue(dev);
551 set_reset_mode(dev);
552
553 if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER))
554 free_irq(dev->irq, (void *)dev);
555
556 close_candev(dev);
557
558 priv->open_time = 0;
559
560 return 0;
561}
562
563struct net_device *alloc_sja1000dev(int sizeof_priv)
564{
565 struct net_device *dev;
566 struct sja1000_priv *priv;
567
568 dev = alloc_candev(sizeof(struct sja1000_priv) + sizeof_priv);
569 if (!dev)
570 return NULL;
571
572 priv = netdev_priv(dev);
573
574 priv->dev = dev;
575 priv->can.bittiming_const = &sja1000_bittiming_const;
576 priv->can.do_set_bittiming = sja1000_set_bittiming;
577 priv->can.do_set_mode = sja1000_set_mode;
578
579 if (sizeof_priv)
580 priv->priv = (void *)priv + sizeof(struct sja1000_priv);
581
582 return dev;
583}
584EXPORT_SYMBOL_GPL(alloc_sja1000dev);
585
586void free_sja1000dev(struct net_device *dev)
587{
588 free_candev(dev);
589}
590EXPORT_SYMBOL_GPL(free_sja1000dev);
591
592static const struct net_device_ops sja1000_netdev_ops = {
593 .ndo_open = sja1000_open,
594 .ndo_stop = sja1000_close,
595 .ndo_start_xmit = sja1000_start_xmit,
596};
597
598int register_sja1000dev(struct net_device *dev)
599{
600 if (!sja1000_probe_chip(dev))
601 return -ENODEV;
602
603 dev->flags |= IFF_ECHO;
604 dev->netdev_ops = &sja1000_netdev_ops;
605
606 set_reset_mode(dev);
607 chipset_init(dev);
608
609 return register_candev(dev);
610}
611EXPORT_SYMBOL_GPL(register_sja1000dev);
612
613void unregister_sja1000dev(struct net_device *dev)
614{
615 set_reset_mode(dev);
616 unregister_candev(dev);
617}
618EXPORT_SYMBOL_GPL(unregister_sja1000dev);
619
620static __init int sja1000_init(void)
621{
622 printk(KERN_INFO "%s CAN netdevice driver\n", DRV_NAME);
623
624 return 0;
625}
626
627module_init(sja1000_init);
628
629static __exit void sja1000_exit(void)
630{
631 printk(KERN_INFO "%s: driver removed\n", DRV_NAME);
632}
633
634module_exit(sja1000_exit);
635