kernel/2.6/drivers/net/can/old/sja1000/sja1000.c

   1 /*
   2  * sja1000.c -  Philips SJA1000 network device driver
   3  *
   4  * Copyright (c) 2003 Matthias Brukner, Trajet Gmbh, Rebenring 33,
   5  * 38106 Braunschweig, GERMANY
   6  *
   7  * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  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.
  21  *
  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.
  26  *
  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.
  29  *
  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
  41  * DAMAGE.
  42  *
  43  * Send feedback to <socketcan-users@lists.berlios.de>
  44  *
  45  */
  46
  47 #include <linux/module.h>
  48 #include <linux/init.h>
  49 #include <linux/version.h>
  50 #include <linux/kernel.h>
  51 #include <linux/sched.h>
  52 #include <linux/types.h>
  53 #include <linux/fcntl.h>
  54 #include <linux/interrupt.h>
  55 #include <linux/ptrace.h>
  56 #include <linux/string.h>
  57 #include <linux/errno.h>
  58 #include <linux/netdevice.h>
  59 #include <linux/if_arp.h>
  60 #include <linux/if_ether.h>
  61 #include <linux/skbuff.h>
  62
  63 #include <linux/can.h>
  64 #include <linux/can/ioctl.h> /* for struct can_device_stats */
  65 #include "sja1000.h"
  66 #include "hal.h"
  67
  68 #include <linux/can/version.h> /* for RCSID. Removed by mkpatch script */
  69 RCSID("$Id$");
  70
  71 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
  72 MODULE_LICENSE("Dual BSD/GPL");
  73 MODULE_DESCRIPTION("LLCF/socketcan '" CHIP_NAME "' network device driver");
  74
  75 #ifdef CONFIG_CAN_DEBUG_DEVICES
  76 #define DBG(args...)   ((priv->debug > 0) ? printk(args) : 0)
  77 /* logging in interrupt context! */
  78 #define iDBG(args...)  ((priv->debug > 1) ? printk(args) : 0)
  79 #define iiDBG(args...) ((priv->debug > 2) ? printk(args) : 0)
  80 #else
  81 #define DBG(args...)
  82 #define iDBG(args...)
  83 #define iiDBG(args...)
  84 #endif
  85
  86 char drv_name[DRV_NAME_LEN] = "undefined";
  87
  88 /* driver and version information */
  89 static const char *drv_version  = "0.1.1";
  90 static const char *drv_reldate  = "2007-04-13";
  91
  92 #ifdef CONFIG_CAN_DEBUG_DEVICES
  93 static const char *ecc_errors[] = {
  94         NULL,
  95         NULL,
  96         "ID.28 to ID.28",
  97         "start of frame",
  98         "bit SRTR",
  99         "bit IDE",
 100         "ID.20 to ID.18",
 101         "ID.17 to ID.13",
 102         "CRC sequence",
 103         "reserved bit 0",
 104         "data field",
 105         "data length code",
 106         "bit RTR",
 107         "reserved bit 1",
 108         "ID.4 to ID.0",
 109         "ID.12 to ID.5",
 110         NULL,
 111         "active error flag",
 112         "intermission",
 113         "tolerate dominant bits",
 114         NULL,
 115         NULL,
 116         "passive error flag",
 117         "error delimiter",
 118         "CRC delimiter",
 119         "acknowledge slot",
 120         "end of frame",
 121         "acknowledge delimiter",
 122         "overload flag",
 123         NULL,
 124         NULL,
 125         NULL
 126 };
 127
 128 static const char *ecc_types[] = {
 129         "bit error",
 130         "form error",
 131         "stuff error",
 132         "other type of error"
 133 };
 134 #endif
 135
 136 /* array of all can chips */
 137 struct net_device *can_dev[MAXDEV];
 138
 139 /* module parameters */
 140 unsigned long base[MAXDEV]      = { 0 }; /* hardware address */
 141 unsigned long rbase[MAXDEV]     = { 0 }; /* (remapped) device address */
 142 unsigned int  irq[MAXDEV]       = { 0 };
 143
 144 unsigned int speed[MAXDEV]      = { DEFAULT_SPEED, DEFAULT_SPEED };
 145 unsigned int btr[MAXDEV]        = { 0 };
 146
 147 static int rx_probe[MAXDEV]     = { 0 };
 148 static int clk                  = DEFAULT_HW_CLK;
 149 static int debug                = 0;
 150 static int restart_ms           = 100;
 151 static int echo                 = 1;
 152
 153 static int base_n;
 154 static int irq_n;
 155 static int speed_n;
 156 static int btr_n;
 157 static int rx_probe_n;
 158
 159 module_param_array(base, int, &base_n, 0);
 160 module_param_array(irq, int, &irq_n, 0);
 161 module_param_array(speed, int, &speed_n, 0);
 162 module_param_array(btr, int, &btr_n, 0);
 163 module_param_array(rx_probe, int, &rx_probe_n, 0);
 164
 165 module_param(clk, int, 0);
 166 module_param(debug, int, 0);
 167 module_param(restart_ms, int, 0);
 168 module_param(echo, int, S_IRUGO);
 169
 170 MODULE_PARM_DESC(base, "CAN controller base address");
 171 MODULE_PARM_DESC(irq, "CAN controller interrupt");
 172 MODULE_PARM_DESC(speed, "CAN bus bitrate");
 173 MODULE_PARM_DESC(btr, "Bit Timing Register value 0x<btr0><btr1>, e.g. 0x4014");
 174 MODULE_PARM_DESC(rx_probe, "switch to trx mode after correct msg receiption. (default off)");
 175
 176 MODULE_PARM_DESC(clk, "CAN controller chip clock (default: 16MHz)");
 177 MODULE_PARM_DESC(debug, "set debug mask (default: 0)");
 178 MODULE_PARM_DESC(restart_ms, "restart chip on heavy bus errors / bus off after x ms (default 100ms)");
 179 MODULE_PARM_DESC(echo, "Echo sent frames. default: 1 (On)");
 180
 181 /*
 182  * CAN network devices *should* support a local echo functionality
 183  * (see Documentation/networking/can.txt). To test the handling of CAN
 184  * interfaces that do not support the local echo both driver types are
 185  * implemented inside this sja1000 driver. In the case that the driver does
 186  * not support the echo the IFF_ECHO remains clear in dev->flags.
 187  * This causes the PF_CAN core to perform the echo as a fallback solution.
 188  */
 189
 190 /* function declarations */
 191
 192 static void can_restart_dev(unsigned long data);
 193 static void chipset_init(struct net_device *dev, int wake);
 194 static void chipset_init_rx(struct net_device *dev);
 195 static void chipset_init_trx(struct net_device *dev);
 196 static void can_netdev_setup(struct net_device *dev);
 197 static struct net_device* can_create_netdev(int dev_num, int hw_regs);
 198 static int  can_set_drv_name(void);
 199 int set_reset_mode(struct net_device *dev);
 200
 201 static int sja1000_probe_chip(unsigned long base)
 202 {
 203         if (base && (hw_readreg(base, 0) == 0xFF)) {
 204                 printk(KERN_INFO "%s: probing @0x%lX failed\n",
 205                        drv_name, base);
 206                 return 0;
 207         }
 208         return 1;
 209 }
 210
 211 /*
 212  * set baud rate divisor values
 213  */
 214 static void set_btr(struct net_device *dev, int btr0, int btr1)
 215 {
 216         struct can_priv *priv = netdev_priv(dev);
 217
 218         /* no bla bla when restarting the device */
 219         if (priv->state == STATE_UNINITIALIZED)
 220                 printk(KERN_INFO "%s: setting BTR0=%02X BTR1=%02X\n",
 221                        dev->name, btr0, btr1);
 222
 223         hw_writereg(dev->base_addr, REG_BTR0, btr0);
 224         hw_writereg(dev->base_addr, REG_BTR1, btr1);
 225 }
 226
 227 /*
 228  * calculate baud rate divisor values
 229  */
 230 static void set_baud(struct net_device *dev, int baud, int clock)
 231 {
 232         struct can_priv *priv = netdev_priv(dev);
 233
 234         int error;
 235         int brp;
 236         int tseg;
 237         int tseg1 = 0;
 238         int tseg2 = 0;
 239
 240         int best_error = 1000000000;
 241         int best_tseg = 0;
 242         int best_brp = 0;
 243         int best_baud = 0;
 244
 245         int SAM = (baud > 100000 ? 0 : 1);
 246
 247         clock >>= 1;
 248
 249         for (tseg = (0 + 0 + 2) * 2;
 250              tseg <= (MAX_TSEG2 + MAX_TSEG1 + 2) * 2 + 1;
 251              tseg++) {
 252                 brp = clock / ((1 + tseg / 2) * baud) + tseg % 2;
 253                 if ((brp > 0) && (brp <= 64)) {
 254                         error = baud - clock / (brp * (1 + tseg / 2));
 255                         if (error < 0) {
 256                                 error = -error;
 257                         }
 258                         if (error <= best_error) {
 259                                 best_error = error;
 260                                 best_tseg = tseg / 2;
 261                                 best_brp = brp - 1;
 262                                 best_baud = clock / (brp * (1 + tseg / 2));
 263                         }
 264                 }
 265         }
 266         if (best_error && (baud / best_error < 10)) {
 267                 printk("%s: unable to set baud rate %d (ext clock %dHz)\n",
 268                        dev->name, baud, clock * 2);
 269                 return;
 270 //              return -EINVAL;
 271         }
 272         tseg2 = best_tseg - (SAMPLE_POINT * (best_tseg + 1)) / 100;
 273         if (tseg2 < 0) {
 274                 tseg2 = 0;
 275         } else if (tseg2 > MAX_TSEG2) {
 276                 tseg2 = MAX_TSEG2;
 277         }
 278         tseg1 = best_tseg - tseg2 - 2;
 279         if (tseg1 > MAX_TSEG1) {
 280                 tseg1 = MAX_TSEG1;
 281                 tseg2 = best_tseg - tseg1 - 2;
 282         }
 283
 284         priv->btr = ((best_brp | JUMPWIDTH)<<8) +
 285                 ((SAM << 7) | (tseg2 << 4) | tseg1);
 286
 287         printk(KERN_INFO "%s: calculated best baudrate: %d / btr is 0x%04X\n",
 288                dev->name, best_baud, priv->btr);
 289
 290         set_btr(dev, (priv->btr>>8) & 0xFF, priv->btr & 0xFF);
 291 //      set_btr(dev, best_brp | JUMPWIDTH, (SAM << 7) | (tseg2 << 4) | tseg1);
 292 }
 293
 294 int set_reset_mode(struct net_device *dev)
 295 {
 296         struct can_priv *priv = netdev_priv(dev);
 297         unsigned char status = hw_readreg(dev->base_addr, REG_MOD);
 298         int i;
 299
 300         priv->can_stats.bus_error_at_init = priv->can_stats.bus_error;
 301
 302         /* disable interrupts */
 303         hw_writereg(dev->base_addr, REG_IER, IRQ_OFF);
 304
 305         for (i = 0; i < 10; i++) {
 306                 /* check reset bit */
 307                 if (status & MOD_RM) {
 308                         if (i > 1) {
 309                                 iDBG(KERN_INFO "%s: %s looped %d times\n",
 310                                      dev->name, __FUNCTION__, i);
 311                         }
 312                         priv->state = STATE_RESET_MODE;
 313                         return 0;
 314                 }
 315
 316                 hw_writereg(dev->base_addr, REG_MOD, MOD_RM); /* reset chip */
 317                 status = hw_readreg(dev->base_addr, REG_MOD);
 318
 319         }
 320
 321         printk(KERN_ERR "%s: setting sja1000 into reset mode failed!\n",
 322                dev->name);
 323         return 1;
 324
 325 }
 326
 327 static int set_normal_mode(struct net_device *dev)
 328 {
 329         unsigned char status = hw_readreg(dev->base_addr, REG_MOD);
 330         int i;
 331
 332         for (i = 0; i < 10; i++) {
 333                 /* check reset bit */
 334                 if ((status & MOD_RM) == 0) {
 335 #ifdef CONFIG_CAN_DEBUG_DEVICES
 336                         if (i > 1) {
 337                                 struct can_priv *priv = netdev_priv(dev);
 338                                 iDBG(KERN_INFO "%s: %s looped %d times\n",
 339                                      dev->name, __FUNCTION__, i);
 340                         }
 341 #endif
 342                         return 0;
 343                 }
 344
 345                 /* set chip to normal mode */
 346                 hw_writereg(dev->base_addr, REG_MOD, 0x00);
 347                 status = hw_readreg(dev->base_addr, REG_MOD);
 348         }
 349
 350         printk(KERN_ERR "%s: setting sja1000 into normal mode failed!\n",
 351                dev->name);
 352         return 1;
 353
 354 }
 355
 356 static int set_listen_mode(struct net_device *dev)
 357 {
 358         unsigned char status = hw_readreg(dev->base_addr, REG_MOD);
 359         int i;
 360
 361         for (i = 0; i < 10; i++) {
 362                 /* check reset mode bit */
 363                 if ((status & MOD_RM) == 0) {
 364 #ifdef CONFIG_CAN_DEBUG_DEVICES
 365                         if (i > 1) {
 366                                 struct can_priv *priv = netdev_priv(dev);
 367                                 iDBG(KERN_INFO "%s: %s looped %d times\n",
 368                                      dev->name, __FUNCTION__, i);
 369                         }
 370 #endif
 371                         return 0;
 372                 }
 373
 374                 /* set listen only mode, clear reset */
 375                 hw_writereg(dev->base_addr, REG_MOD, MOD_LOM);
 376                 status = hw_readreg(dev->base_addr, REG_MOD);
 377         }
 378
 379         printk(KERN_ERR "%s: setting sja1000 into listen mode failed!\n",
 380                dev->name);
 381         return 1;
 382
 383 }
 384
 385 /*
 386  * initialize SJA1000 chip:
 387  *   - reset chip
 388  *   - set output mode
 389  *   - set baudrate
 390  *   - enable interrupts
 391  *   - start operating mode
 392  */
 393 static void chipset_init_regs(struct net_device *dev)
 394 {
 395         struct can_priv *priv = netdev_priv(dev);
 396         unsigned long base = dev->base_addr;
 397
 398         /* go into Pelican mode, disable clkout, disable comparator */
 399         hw_writereg(base, REG_CDR, 0xCF);
 400
 401         /* output control */
 402         /* connected to external transceiver */
 403         hw_writereg(base, REG_OCR, 0x1A);
 404
 405         /* set acceptance filter (accept all) */
 406         hw_writereg(base, REG_ACCC0, 0x00);
 407         hw_writereg(base, REG_ACCC1, 0x00);
 408         hw_writereg(base, REG_ACCC2, 0x00);
 409         hw_writereg(base, REG_ACCC3, 0x00);
 410
 411         hw_writereg(base, REG_ACCM0, 0xFF);
 412         hw_writereg(base, REG_ACCM1, 0xFF);
 413         hw_writereg(base, REG_ACCM2, 0xFF);
 414         hw_writereg(base, REG_ACCM3, 0xFF);
 415
 416         /* set baudrate */
 417         if (priv->btr) { /* no calculation when btr is provided */
 418                 set_btr(dev, (priv->btr>>8) & 0xFF, priv->btr & 0xFF);
 419         } else {
 420                 if (priv->speed == 0) {
 421                         priv->speed = DEFAULT_SPEED;
 422                 }
 423                 set_baud(dev, priv->speed * 1000, priv->clock);
 424         }
 425
 426         /* output control */
 427         /* connected to external transceiver */
 428         hw_writereg(base, REG_OCR, 0x1A);
 429 }
 430
 431 static void chipset_init(struct net_device *dev, int wake)
 432 {
 433         struct can_priv *priv = netdev_priv(dev);
 434
 435         if (priv->rx_probe)
 436                 chipset_init_rx(dev); /* wait for valid reception first */
 437         else
 438                 chipset_init_trx(dev);
 439
 440         if ((wake) && netif_queue_stopped(dev)) {
 441                 if (priv->echo_skb) { /* pending echo? */
 442                         kfree_skb(priv->echo_skb);
 443                         priv->echo_skb = NULL;
 444                 }
 445                 netif_wake_queue(dev);
 446         }
 447 }
 448
 449 static void chipset_init_rx(struct net_device *dev)
 450 {
 451         struct can_priv *priv = netdev_priv(dev);
 452
 453         iDBG(KERN_INFO "%s: %s()\n", dev->name, __FUNCTION__);
 454
 455         /* set chip into reset mode */
 456         set_reset_mode(dev);
 457
 458         /* set registers */
 459         chipset_init_regs(dev);
 460
 461         /* automatic bit rate detection */
 462         set_listen_mode(dev);
 463
 464         priv->state = STATE_PROBE;
 465
 466         /* enable receive and error interrupts */
 467         hw_writereg(dev->base_addr, REG_IER, IRQ_RI | IRQ_EI);
 468 }
 469
 470 static void chipset_init_trx(struct net_device *dev)
 471 {
 472         struct can_priv *priv = netdev_priv(dev);
 473
 474         iDBG(KERN_INFO "%s: %s()\n", dev->name, __FUNCTION__);
 475
 476         /* set chip into reset mode */
 477         set_reset_mode(dev);
 478
 479         /* set registers */
 480         chipset_init_regs(dev);
 481
 482         /* leave reset mode */
 483         set_normal_mode(dev);
 484
 485         priv->state = STATE_ACTIVE;
 486
 487         /* enable all interrupts */
 488         hw_writereg(dev->base_addr, REG_IER, IRQ_ALL);
 489 }
 490
 491 /*
 492  * transmit a CAN message
 493  * message layout in the sk_buff should be like this:
 494  * xx xx xx xx   ff      ll   00 11 22 33 44 55 66 77
 495  * [  can-id ] [flags] [len] [can data (up to 8 bytes]
 496  */
 497 static int can_start_xmit(struct sk_buff *skb, struct net_device *dev)
 498 {
 499         struct can_priv  *priv  = netdev_priv(dev);
 500         struct net_device_stats *stats = dev->get_stats(dev);
 501         struct can_frame *cf    = (struct can_frame*)skb->data;
 502         unsigned long base      = dev->base_addr;
 503         uint8_t fi;
 504         uint8_t dlc;
 505         canid_t id;
 506         uint8_t dreg;
 507         int     loop;
 508         int     i;
 509
 510         netif_stop_queue(dev);
 511
 512         fi = dlc = cf->can_dlc;
 513         id = cf->can_id;
 514
 515         if (id & CAN_RTR_FLAG)
 516                 fi |= FI_RTR;
 517
 518         if (id & CAN_EFF_FLAG) {
 519                 fi |= FI_FF;
 520                 dreg = EFF_BUF;
 521                 hw_writereg(base, REG_FI, fi);
 522                 hw_writereg(base, REG_ID1, (id & 0x1fe00000) >> (5 + 16));
 523                 hw_writereg(base, REG_ID2, (id & 0x001fe000) >> (5 + 8));
 524                 hw_writereg(base, REG_ID3, (id & 0x00001fe0) >> 5);
 525                 hw_writereg(base, REG_ID4, (id & 0x0000001f) << 3);
 526         } else {
 527                 dreg = SFF_BUF;
 528                 hw_writereg(base, REG_FI, fi);
 529                 hw_writereg(base, REG_ID1, (id & 0x000007f8) >> 3);
 530                 hw_writereg(base, REG_ID2, (id & 0x00000007) << 5);
 531         }
 532
 533         for (i = 0; i < dlc; i++) {
 534                 hw_writereg(base, dreg++, cf->data[i]);
 535         }
 536
 537         hw_writereg(base, REG_CMR, CMD_TR);
 538
 539         stats->tx_bytes += dlc;
 540
 541         dev->trans_start = jiffies;
 542
 543         /* set flag whether this packet has to be looped back */
 544         loop = skb->pkt_type == PACKET_LOOPBACK;
 545
 546         if (!echo || !loop) {
 547                 kfree_skb(skb);
 548                 return 0;
 549         }
 550
 551         if (!priv->echo_skb) {
 552                 struct sock *srcsk = skb->sk;
 553
 554                 if (atomic_read(&skb->users) != 1) {
 555                         struct sk_buff *old_skb = skb;
 556
 557                         skb = skb_clone(old_skb, GFP_ATOMIC);
 558                         DBG(KERN_INFO "%s: %s: freeing old skbuff %p, "
 559                             "using new skbuff %p\n",
 560                             dev->name, __FUNCTION__, old_skb, skb);
 561                         kfree_skb(old_skb);
 562                         if (!skb) {
 563                                 return 0;
 564                         }
 565                 } else
 566                         skb_orphan(skb);
 567
 568                 skb->sk = srcsk;
 569
 570                 /* make settings for echo to reduce code in irq context */
 571                 skb->protocol   = htons(ETH_P_CAN);
 572                 skb->pkt_type   = PACKET_BROADCAST;
 573                 skb->ip_summed  = CHECKSUM_UNNECESSARY;
 574                 skb->dev        = dev;
 575
 576                 /* save this skb for tx interrupt echo handling */
 577                 priv->echo_skb = skb;
 578
 579         } else {
 580                 /* locking problem with netif_stop_queue() ?? */
 581                 printk(KERN_ERR "%s: %s: occupied echo_skb!\n",
 582                        dev->name, __FUNCTION__ );
 583                 kfree_skb(skb);
 584         }
 585
 586         return 0;
 587 }
 588
 589 static void can_tx_timeout(struct net_device *dev)
 590 {
 591         struct can_priv *priv = netdev_priv(dev);
 592         struct net_device_stats *stats = dev->get_stats(dev);
 593
 594         stats->tx_errors++;
 595
 596         /* do not conflict with e.g. bus error handling */
 597         if (!(priv->timer.expires)){ /* no restart on the run */
 598                 chipset_init_trx(dev); /* no tx queue wakeup */
 599                 if (priv->echo_skb) { /* pending echo? */
 600                         kfree_skb(priv->echo_skb);
 601                         priv->echo_skb = NULL;
 602                 }
 603                 netif_wake_queue(dev); /* wakeup here */
 604         }
 605         else
 606                 DBG(KERN_INFO "%s: %s: can_restart_dev already active.\n",
 607                     dev->name, __FUNCTION__ );
 608
 609 }
 610
 611 static void can_restart_on(struct net_device *dev)
 612 {
 613         struct can_priv *priv = netdev_priv(dev);
 614
 615         if (!(priv->timer.expires)){ /* no restart on the run */
 616
 617                 set_reset_mode(dev);
 618
 619                 priv->timer.function = can_restart_dev;
 620                 priv->timer.data = (unsigned long) dev;
 621
 622                 /* restart chip on persistent error in <xxx> ms */
 623                 priv->timer.expires = jiffies + (priv->restart_ms * HZ) / 1000;
 624                 add_timer(&priv->timer);
 625
 626                 iDBG(KERN_INFO "%s: %s start (%ld)\n",
 627                      dev->name, __FUNCTION__ , jiffies);
 628         } else
 629                 iDBG(KERN_INFO "%s: %s already (%ld)\n",
 630                      dev->name, __FUNCTION__ , jiffies);
 631 }
 632
 633 static void can_restart_dev(unsigned long data)
 634 {
 635         struct net_device *dev = (struct net_device*) data;
 636         struct can_priv *priv = netdev_priv(dev);
 637
 638         DBG(KERN_INFO "%s: can_restart_dev (%ld)\n",
 639             dev->name, jiffies);
 640
 641         /* mark inactive timer */
 642         priv->timer.expires = 0;
 643
 644         if (priv->state != STATE_UNINITIALIZED) {
 645
 646                 /* count number of restarts */
 647                 priv->can_stats.restarts++;
 648
 649                 chipset_init(dev, 1);
 650         }
 651 }
 652
 653 #if 0
 654 /* the timerless version */
 655
 656 static void can_restart_now(struct net_device *dev)
 657 {
 658         struct can_priv *priv = netdev_priv(dev);
 659
 660         if (priv->state != STATE_UNINITIALIZED) {
 661
 662                 /* count number of restarts */
 663                 priv->can_stats.restarts++;
 664
 665                 chipset_init(dev, 1);
 666         }
 667 }
 668 #endif
 669
 670 static void can_rx(struct net_device *dev)
 671 {
 672         struct net_device_stats *stats = dev->get_stats(dev);
 673         unsigned long base = dev->base_addr;
 674         struct can_frame *cf;
 675         struct sk_buff  *skb;
 676         uint8_t fi;
 677         uint8_t dreg;
 678         canid_t id;
 679         uint8_t dlc;
 680         int     i;
 681
 682         skb = dev_alloc_skb(sizeof(struct can_frame));
 683         if (skb == NULL) {
 684                 return;
 685         }
 686         skb->dev = dev;
 687         skb->protocol = htons(ETH_P_CAN);
 688
 689         fi = hw_readreg(base, REG_FI);
 690         dlc = fi & 0x0F;
 691
 692         if (fi & FI_FF) {
 693                 /* extended frame format (EFF) */
 694                 dreg = EFF_BUF;
 695                 id = (hw_readreg(base, REG_ID1) << (5+16))
 696                         | (hw_readreg(base, REG_ID2) << (5+8))
 697                         | (hw_readreg(base, REG_ID3) << 5)
 698                         | (hw_readreg(base, REG_ID4) >> 3);
 699                 id |= CAN_EFF_FLAG;
 700         } else {
 701                 /* standard frame format (SFF) */
 702                 dreg = SFF_BUF;
 703                 id = (hw_readreg(base, REG_ID1) << 3)
 704                         | (hw_readreg(base, REG_ID2) >> 5);
 705         }
 706
 707         if (fi & FI_RTR)
 708                 id |= CAN_RTR_FLAG;
 709
 710         cf = (struct can_frame*)skb_put(skb, sizeof(struct can_frame));
 711         memset(cf, 0, sizeof(struct can_frame));
 712         cf->can_id    = id;
 713         cf->can_dlc   = dlc;
 714         for (i = 0; i < dlc; i++) {
 715                 cf->data[i] = hw_readreg(base, dreg++);
 716         }
 717         while (i < 8)
 718                 cf->data[i++] = 0;
 719
 720         /* release receive buffer */
 721         hw_writereg(base, REG_CMR, CMD_RRB);
 722
 723         netif_rx(skb);
 724
 725         dev->last_rx = jiffies;
 726         stats->rx_packets++;
 727         stats->rx_bytes += dlc;
 728 }
 729
 730 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 731 static struct net_device_stats *can_get_stats(struct net_device *dev)
 732 {
 733         struct can_priv *priv = netdev_priv(dev);
 734
 735         /* TODO: read statistics from chip */
 736         return &priv->stats;
 737 }
 738 #endif
 739
 740 static int can_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 741 {
 742         if (!netif_running(dev))
 743                 return -EINVAL;
 744
 745         switch (cmd) {
 746         case SIOCSCANBAUDRATE:
 747                 ;
 748                 return 0;
 749         case SIOCGCANBAUDRATE:
 750                 ;
 751                 return 0;
 752         }
 753         return 0;
 754 }
 755
 756 /*
 757  * SJA1000 interrupt handler
 758  */
 759 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 760 static irqreturn_t can_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 761 #else
 762 static irqreturn_t can_interrupt(int irq, void *dev_id)
 763 #endif
 764 {
 765         struct net_device *dev  = (struct net_device*)dev_id;
 766         struct can_priv *priv   = netdev_priv(dev);
 767         struct net_device_stats *stats = dev->get_stats(dev);
 768         unsigned long base      = dev->base_addr;
 769         uint8_t isrc, status, ecc, alc;
 770         int n = 0;
 771
 772         hw_preirq(dev);
 773
 774         iiDBG(KERN_INFO "%s: interrupt\n", dev->name);
 775
 776         if (priv->state == STATE_UNINITIALIZED) {
 777                 printk(KERN_ERR "%s: %s: uninitialized controller!\n",
 778                        dev->name, __FUNCTION__);
 779                 chipset_init(dev, 1); /* should be possible at this stage */
 780                 return IRQ_NONE;
 781         }
 782
 783         if (priv->state == STATE_RESET_MODE) {
 784                 iiDBG(KERN_ERR "%s: %s: controller is in reset mode! "
 785                       "MOD=0x%02X IER=0x%02X IR=0x%02X SR=0x%02X!\n",
 786                       dev->name, __FUNCTION__, hw_readreg(base, REG_MOD),
 787                       hw_readreg(base, REG_IER), hw_readreg(base, REG_IR),
 788                       hw_readreg(base, REG_SR));
 789                 return IRQ_NONE;
 790         }
 791
 792         while ((isrc = hw_readreg(base, REG_IR)) && (n < 20)) {
 793                 n++;
 794                 status = hw_readreg(base, REG_SR);
 795
 796                 if (isrc & IRQ_WUI) {
 797                         /* wake-up interrupt */
 798                         priv->can_stats.wakeup++;
 799                 }
 800                 if (isrc & IRQ_TI) {
 801                         /* transmission complete interrupt */
 802                         stats->tx_packets++;
 803
 804                         if (echo && priv->echo_skb) {
 805                                 netif_rx(priv->echo_skb);
 806                                 priv->echo_skb = NULL;
 807                         }
 808
 809                         netif_wake_queue(dev);
 810                 }
 811                 if (isrc & IRQ_RI) {
 812                         /* receive interrupt */
 813
 814                         while (status & SR_RBS) {
 815                                 can_rx(dev);
 816                                 status = hw_readreg(base, REG_SR);
 817                         }
 818                         if (priv->state == STATE_PROBE) {
 819                                 /* valid RX -> switch to trx-mode */
 820                                 iDBG(KERN_INFO "%s: RI #%d#\n", dev->name, n);
 821                                 chipset_init_trx(dev); /* no tx queue wakeup */
 822                                 break; /* check again after init controller */
 823                         }
 824                 }
 825                 if (isrc & IRQ_DOI) {
 826                         /* data overrun interrupt */
 827                         iiDBG(KERN_INFO "%s: data overrun isrc=0x%02X "
 828                               "status=0x%02X\n",
 829                               dev->name, isrc, status);
 830                         iDBG(KERN_INFO "%s: DOI #%d#\n", dev->name, n);
 831                         priv->can_stats.data_overrun++;
 832                         hw_writereg(base, REG_CMR, CMD_CDO); /* clear bit */
 833                 }
 834                 if (isrc & IRQ_EI) {
 835                         /* error warning interrupt */
 836                         iiDBG(KERN_INFO "%s: error warning isrc=0x%02X "
 837                               "status=0x%02X\n",
 838                               dev->name, isrc, status);
 839                         iDBG(KERN_INFO "%s: EI #%d#\n", dev->name, n);
 840                         priv->can_stats.error_warning++;
 841                         if (status & SR_BS) {
 842                                 printk(KERN_INFO "%s: BUS OFF, "
 843                                        "restarting device\n", dev->name);
 844                                 can_restart_on(dev);
 845                                 /* controller has been restarted: leave here */
 846                                 goto out;
 847                         } else if (status & SR_ES) {
 848                                 iDBG(KERN_INFO "%s: error\n", dev->name);
 849                         }
 850                 }
 851                 if (isrc & IRQ_BEI) {
 852                         /* bus error interrupt */
 853                         iiDBG(KERN_INFO "%s: bus error isrc=0x%02X "
 854                               "status=0x%02X\n",
 855                               dev->name, isrc, status);
 856                         iDBG(KERN_INFO "%s: BEI #%d# [%d]\n", dev->name, n,
 857                              priv->can_stats.bus_error -
 858                              priv->can_stats.bus_error_at_init);
 859                         priv->can_stats.bus_error++;
 860                         ecc = hw_readreg(base, REG_ECC);
 861                         iDBG(KERN_INFO "%s: ECC = 0x%02X (%s, %s, %s)\n",
 862                              dev->name, ecc,
 863                              (ecc & ECC_DIR) ? "RX" : "TX",
 864                              ecc_types[ecc >> ECC_ERR],
 865                              ecc_errors[ecc & ECC_SEG]);
 866
 867                         /* when the bus errors flood the system, */
 868                         /* restart the controller                */
 869                         if (priv->can_stats.bus_error_at_init +
 870                             MAX_BUS_ERRORS < priv->can_stats.bus_error) {
 871                                 iDBG(KERN_INFO "%s: heavy bus errors,"
 872                                      " restarting device\n", dev->name);
 873                                 can_restart_on(dev);
 874                                 /* controller has been restarted: leave here */
 875                                 goto out;
 876                         }
 877 #if 1
 878                         /* don't know, if this is a good idea, */
 879                         /* but it works fine ...               */
 880                         if (hw_readreg(base, REG_RXERR) > 128) {
 881                                 iDBG(KERN_INFO "%s: RX_ERR > 128,"
 882                                      " restarting device\n", dev->name);
 883                                 can_restart_on(dev);
 884                                 /* controller has been restarted: leave here */
 885                                 goto out;
 886                         }
 887 #endif
 888                 }
 889                 if (isrc & IRQ_EPI) {
 890                         /* error passive interrupt */
 891                         iiDBG(KERN_INFO "%s: error passive isrc=0x%02X"
 892                               " status=0x%02X\n",
 893                               dev->name, isrc, status);
 894                         iDBG(KERN_INFO "%s: EPI #%d#\n", dev->name, n);
 895                         priv->can_stats.error_passive++;
 896                         if (status & SR_ES) {
 897                                 iDBG(KERN_INFO "%s: -> ERROR PASSIVE, "
 898                                      "restarting device\n", dev->name);
 899                                 can_restart_on(dev);
 900                                 /* controller has been restarted: leave here */
 901                                 goto out;
 902                         } else {
 903                                 iDBG(KERN_INFO "%s: -> ERROR ACTIVE\n",
 904                                      dev->name);
 905                         }
 906                 }
 907                 if (isrc & IRQ_ALI) {
 908                         /* arbitration lost interrupt */
 909                         iiDBG(KERN_INFO "%s: error arbitration lost "
 910                               "isrc=0x%02X status=0x%02X\n",
 911                               dev->name, isrc, status);
 912                         iDBG(KERN_INFO "%s: ALI #%d#\n", dev->name, n);
 913                         priv->can_stats.arbitration_lost++;
 914                         alc = hw_readreg(base, REG_ALC);
 915                         iDBG(KERN_INFO "%s: ALC = 0x%02X\n", dev->name, alc);
 916                 }
 917         }
 918         if (n > 1) {
 919                 iDBG(KERN_INFO "%s: handled %d IRQs\n", dev->name, n);
 920         }
 921 out:
 922         hw_postirq(dev);
 923
 924         return n == 0 ? IRQ_NONE : IRQ_HANDLED;
 925 }
 926
 927 /*
 928  * initialize CAN bus driver
 929  */
 930 static int can_open(struct net_device *dev)
 931 {
 932         struct can_priv *priv = netdev_priv(dev);
 933
 934         /* set chip into reset mode */
 935         set_reset_mode(dev);
 936
 937         priv->state = STATE_UNINITIALIZED;
 938
 939         /* register interrupt handler */
 940 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 941         if (request_irq(dev->irq, &can_interrupt, SA_SHIRQ,
 942                         dev->name, (void*)dev)) {
 943 #else
 944         if (request_irq(dev->irq, &can_interrupt, IRQF_SHARED,
 945                         dev->name, (void*)dev)) {
 946 #endif
 947                 return -EAGAIN;
 948         }
 949
 950 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 951         /* clear statistics */
 952         memset(&priv->stats, 0, sizeof(priv->stats));
 953 #endif
 954
 955         /* init chip */
 956         chipset_init(dev, 0);
 957         priv->open_time = jiffies;
 958
 959         netif_start_queue(dev);
 960
 961         return 0;
 962 }
 963
 964 /*
 965  * stop CAN bus activity
 966  */
 967 static int can_close(struct net_device *dev)
 968 {
 969         struct can_priv *priv = netdev_priv(dev);
 970
 971         /* set chip into reset mode */
 972         set_reset_mode(dev);
 973
 974         priv->open_time = 0;
 975
 976         if (priv->timer.expires) {
 977                 del_timer(&priv->timer);
 978                 priv->timer.expires = 0;
 979         }
 980
 981         free_irq(dev->irq, (void*)dev);
 982         priv->state = STATE_UNINITIALIZED;
 983
 984         netif_stop_queue(dev);
 985
 986         return 0;
 987 }
 988
 989 #if 0
 990 static void test_if(struct net_device *dev)
 991 {
 992         int i;
 993         int j;
 994         int x;
 995
 996         hw_writereg(base, REG_CDR, 0xCF);
 997         for (i = 0; i < 10000; i++) {
 998                 for (j = 0; j < 256; j++) {
 999                         hw_writereg(base, REG_EWL, j);
1000                         x = hw_readreg(base, REG_EWL);
1001                         if (x != j) {
1002                                 printk(KERN_INFO "%s: is: %02X expected: "
1003                                        "%02X (%d)\n", dev->name, x, j, i);
1004                         }
1005                 }
1006         }
1007 }
1008 #endif
1009
1010 void can_netdev_setup(struct net_device *dev)
1011 {
1012         /* Fill in the the fields of the device structure
1013            with CAN netdev generic values */
1014
1015         dev->change_mtu                 = NULL;
1016         dev->set_mac_address            = NULL;
1017 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1018         dev->hard_header                = NULL;
1019         dev->rebuild_header             = NULL;
1020         dev->hard_header_cache          = NULL;
1021         dev->header_cache_update        = NULL;
1022         dev->hard_header_parse          = NULL;
1023 #else
1024         dev->header_ops                 = NULL;
1025 #endif
1026
1027         dev->type                       = ARPHRD_CAN;
1028         dev->hard_header_len            = 0;
1029         dev->mtu                        = sizeof(struct can_frame);
1030         dev->addr_len                   = 0;
1031         dev->tx_queue_len               = 10;
1032
1033         dev->flags                      = IFF_NOARP;
1034
1035 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
1036 #define IFF_ECHO IFF_LOOPBACK
1037 #endif
1038         /* set flags according to driver capabilities */
1039         if (echo)
1040                 dev->flags |= IFF_ECHO;
1041
1042         dev->features                   = NETIF_F_NO_CSUM;
1043
1044         dev->open                       = can_open;
1045         dev->stop                       = can_close;
1046         dev->hard_start_xmit            = can_start_xmit;
1047 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
1048         dev->get_stats                  = can_get_stats;
1049 #endif
1050         dev->do_ioctl                   = can_ioctl;
1051
1052         dev->tx_timeout                 = can_tx_timeout;
1053         dev->watchdog_timeo             = TX_TIMEOUT;
1054 }
1055
1056 static struct net_device* can_create_netdev(int dev_num, int hw_regs)
1057 {
1058         struct net_device       *dev;
1059         struct can_priv         *priv;
1060
1061         if (!(dev = alloc_netdev(sizeof(struct can_priv), CAN_NETDEV_NAME,
1062                                  can_netdev_setup))) {
1063                 printk(KERN_ERR "%s: out of memory\n", CHIP_NAME);
1064                 return NULL;
1065         }
1066
1067         printk(KERN_INFO "%s: base 0x%lX / irq %d / speed %d / "
1068                "btr 0x%X / rx_probe %d\n",
1069                drv_name, rbase[dev_num], irq[dev_num],
1070                speed[dev_num], btr[dev_num], rx_probe[dev_num]);
1071
1072         /* fill net_device structure */
1073
1074         priv             = netdev_priv(dev);
1075
1076         dev->irq         = irq[dev_num];
1077         dev->base_addr   = rbase[dev_num];
1078
1079         priv->speed      = speed[dev_num];
1080         priv->btr        = btr[dev_num];
1081         priv->rx_probe   = rx_probe[dev_num];
1082         priv->clock      = clk;
1083         priv->hw_regs    = hw_regs;
1084         priv->restart_ms = restart_ms;
1085         priv->debug      = debug;
1086
1087         init_timer(&priv->timer);
1088         priv->timer.expires = 0;
1089
1090         if (register_netdev(dev)) {
1091                 printk(KERN_INFO "%s: register netdev failed\n", CHIP_NAME);
1092                 free_netdev(dev);
1093                 return NULL;
1094         }
1095
1096         return dev;
1097 }
1098
1099 int can_set_drv_name(void)
1100 {
1101         char *hname = hal_name();
1102
1103         if (strlen(CHIP_NAME) + strlen(hname) >= DRV_NAME_LEN-1) {
1104                 printk(KERN_ERR "%s: driver name too long!\n", CHIP_NAME);
1105                 return -EINVAL;
1106         }
1107         sprintf(drv_name, "%s-%s", CHIP_NAME, hname);
1108         return 0;
1109 }
1110
1111 static __exit void sja1000_exit_module(void)
1112 {
1113         int i, ret;
1114
1115         for (i = 0; i < MAXDEV; i++) {
1116                 if (can_dev[i] != NULL) {
1117                         struct can_priv *priv = netdev_priv(can_dev[i]);
1118                         unregister_netdev(can_dev[i]);
1119                         del_timer(&priv->timer);
1120                         hw_detach(i);
1121                         hal_release_region(i, SJA1000_IO_SIZE_BASIC);
1122                         free_netdev(can_dev[i]);
1123                 }
1124         }
1125         can_proc_remove(drv_name);
1126
1127         if ((ret = hal_exit()))
1128                 printk(KERN_INFO "%s: hal_exit error %d.\n", drv_name, ret);
1129 }
1130
1131 static __init int sja1000_init_module(void)
1132 {
1133         int i, ret;
1134         struct net_device *dev;
1135
1136         if ((ret = hal_init()))
1137                 return ret;
1138
1139         if ((ret = can_set_drv_name()))
1140                 return ret;
1141
1142         if (clk < 1000 ) /* MHz command line value */
1143                 clk *= 1000000;
1144
1145         if (clk < 1000000 ) /* kHz command line value */
1146                 clk *= 1000;
1147
1148         printk(KERN_INFO "%s driver v%s (%s)\n",
1149                drv_name, drv_version, drv_reldate);
1150         printk(KERN_INFO "%s - options [clk %d.%06d MHz] [restart_ms %dms]"
1151                " [debug %d]\n",
1152                drv_name, clk/1000000, clk%1000000, restart_ms, debug);
1153
1154         if (!base[0]) {
1155                 printk(KERN_INFO "%s: loading defaults.\n", drv_name);
1156                 hal_use_defaults();
1157         }
1158
1159         for (i = 0; base[i]; i++) {
1160                 printk(KERN_DEBUG "%s: checking for %s on address 0x%lX ...\n",
1161                        drv_name, CHIP_NAME, base[i]);
1162
1163                 if (!hal_request_region(i, SJA1000_IO_SIZE_BASIC, drv_name)) {
1164                         printk(KERN_ERR "%s: memory already in use\n",
1165                                drv_name);
1166                         sja1000_exit_module();
1167                         return -EBUSY;
1168                 }
1169
1170                 hw_attach(i);
1171                 hw_reset_dev(i);
1172
1173                 if (!sja1000_probe_chip(rbase[i])) {
1174                         printk(KERN_ERR "%s: probably missing controller"
1175                                " hardware\n", drv_name);
1176                         hw_detach(i);
1177                         hal_release_region(i, SJA1000_IO_SIZE_BASIC);
1178                         sja1000_exit_module();
1179                         return -ENODEV;
1180                 }
1181
1182                 dev = can_create_netdev(i, SJA1000_IO_SIZE_BASIC);
1183
1184                 if (dev != NULL) {
1185                         can_dev[i] = dev;
1186                         set_reset_mode(dev);
1187                         can_proc_create(drv_name);
1188                 } else {
1189                         can_dev[i] = NULL;
1190                         hw_detach(i);
1191                         hal_release_region(i, SJA1000_IO_SIZE_BASIC);
1192                 }
1193         }
1194         return 0;
1195 }
1196
1197 module_init(sja1000_init_module);
1198 module_exit(sja1000_exit_module);
1199