kernel/2.6/drivers/net/can/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/kernel.h>
  50 #include <linux/version.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 #include <linux/delay.h>
  63
  64 #include <linux/can.h>
  65 #include <linux/can/dev.h>
  66 #include <linux/can/error.h>
  67 #include <linux/can/dev.h>
  68
  69 #include "sja1000.h"
  70
  71 #include <linux/can/version.h>  /* for RCSID. Removed by mkpatch script */
  72 RCSID("$Id: sja1000.c 531 2007-10-19 07:38:29Z hartkopp $");
  73
  74 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
  75 MODULE_LICENSE("Dual BSD/GPL");
  76 MODULE_DESCRIPTION("Socketcan " CHIP_NAME " network device driver");
  77
  78 #ifdef CONFIG_CAN_DEBUG_DEVICES
  79 #define DBG(args...)   ((debug > 0) ? printk(args) : 0)
  80 /* logging in interrupt context! */
  81 #define iDBG(args...)  ((debug > 1) ? printk(args) : 0)
  82 #define iiDBG(args...) ((debug > 2) ? printk(args) : 0)
  83 #else
  84 #define DBG(args...)
  85 #define iDBG(args...)
  86 #define iiDBG(args...)
  87 #endif
  88
  89 /* driver and version information */
  90 static const char *drv_name = "SJA1000";
  91 static const char *drv_version = "0.2.0";
  92 static const char *drv_reldate = "2007-10-25";
  93
  94 #ifdef CONFIG_CAN_DEBUG_DEVICES
  95 static const char *ecc_errors[] = {
  96         NULL,
  97         NULL,
  98         "ID.28 to ID.28",
  99         "start of frame",
 100         "bit SRTR",
 101         "bit IDE",
 102         "ID.20 to ID.18",
 103         "ID.17 to ID.13",
 104         "CRC sequence",
 105         "reserved bit 0",
 106         "data field",
 107         "data length code",
 108         "bit RTR",
 109         "reserved bit 1",
 110         "ID.4 to ID.0",
 111         "ID.12 to ID.5",
 112         NULL,
 113         "active error flag",
 114         "intermission",
 115         "tolerate dominant bits",
 116         NULL,
 117         NULL,
 118         "passive error flag",
 119         "error delimiter",
 120         "CRC delimiter",
 121         "acknowledge slot",
 122         "end of frame",
 123         "acknowledge delimiter",
 124         "overload flag",
 125         NULL,
 126         NULL,
 127         NULL
 128 };
 129
 130 static const char *ecc_types[] = {
 131         "bit error",
 132         "form error",
 133         "stuff error",
 134         "other type of error"
 135 };
 136 #endif
 137
 138 static int debug;
 139
 140 module_param(debug, int, S_IRUGO | S_IWUSR);
 141
 142 MODULE_PARM_DESC(debug, "Set debug mask (default: 0)");
 143
 144
 145 static int sja1000_probe_chip(struct net_device *dev)
 146 {
 147         struct sja1000_priv *priv = netdev_priv(dev);
 148
 149         if (dev->base_addr && (priv->read_reg(dev, 0) == 0xFF)) {
 150                 printk(KERN_INFO "%s: probing @0x%lX failed\n",
 151                        drv_name, dev->base_addr);
 152                 return 0;
 153         }
 154         return 1;
 155 }
 156
 157 int set_reset_mode(struct net_device *dev)
 158 {
 159         struct sja1000_priv *priv = netdev_priv(dev);
 160         unsigned char status = priv->read_reg(dev, REG_MOD);
 161         int i;
 162
 163         /* disable interrupts */
 164         priv->write_reg(dev, REG_IER, IRQ_OFF);
 165
 166         for (i = 0; i < 100; i++) {
 167                 /* check reset bit */
 168                 if (status & MOD_RM) {
 169                         if (i > 1) {
 170                                 iDBG(KERN_INFO "%s: %s looped %d times\n",
 171                                      dev->name, __func__, i);
 172                         }
 173                         priv->can.state = CAN_STATE_STOPPED;
 174                         return 0;
 175                 }
 176
 177                 priv->write_reg(dev, REG_MOD, MOD_RM);  /* reset chip */
 178                 status = priv->read_reg(dev, REG_MOD);
 179                 udelay(10);
 180         }
 181
 182         dev_err(ND2D(dev), "setting SJA1000 into reset mode failed!\n");
 183         return 1;
 184
 185 }
 186
 187 static int set_normal_mode(struct net_device *dev)
 188 {
 189         struct sja1000_priv *priv = netdev_priv(dev);
 190         unsigned char status = priv->read_reg(dev, REG_MOD);
 191         int i;
 192
 193         for (i = 0; i < 100; i++) {
 194                 /* check reset bit */
 195                 if ((status & MOD_RM) == 0) {
 196 #ifdef CONFIG_CAN_DEBUG_DEVICES
 197                         if (i > 1) {
 198                                 iDBG(KERN_INFO "%s: %s looped %d times\n",
 199                                      dev->name, __func__, i);
 200                         }
 201 #endif
 202                         priv->can.state = CAN_STATE_ACTIVE;
 203                         /* enable all interrupts */
 204                         priv->write_reg(dev, REG_IER, IRQ_ALL);
 205
 206                         return 0;
 207                 }
 208
 209                 /* set chip to normal mode */
 210                 priv->write_reg(dev, REG_MOD, 0x00);
 211                 status = priv->read_reg(dev, REG_MOD);
 212                 udelay(10);
 213         }
 214
 215         dev_err(ND2D(dev), "setting SJA1000 into normal mode failed!\n");
 216         return 1;
 217
 218 }
 219
 220 static void sja1000_start(struct net_device *dev)
 221 {
 222         struct sja1000_priv *priv = netdev_priv(dev);
 223
 224         iDBG(KERN_INFO "%s: %s()\n", dev->name, __func__);
 225
 226         /* leave reset mode */
 227         if (priv->can.state != CAN_STATE_STOPPED)
 228                 set_reset_mode(dev);
 229
 230         /* Clear error counters and error code capture */
 231         priv->write_reg(dev, REG_TXERR, 0x0);
 232         priv->write_reg(dev, REG_RXERR, 0x0);
 233         priv->read_reg(dev, REG_ECC);
 234
 235         /* leave reset mode */
 236         set_normal_mode(dev);
 237 }
 238
 239 static int sja1000_set_mode(struct net_device *dev, enum can_mode mode)
 240 {
 241         struct sja1000_priv *priv = netdev_priv(dev);
 242
 243         switch (mode) {
 244         case CAN_MODE_START:
 245                 DBG("%s: CAN_MODE_START requested\n", __func__);
 246                 if (!priv->open_time)
 247                         return -EINVAL;
 248
 249                 sja1000_start(dev);
 250                 if (netif_queue_stopped(dev))
 251                         netif_wake_queue(dev);
 252                 break;
 253
 254         default:
 255                 return -EOPNOTSUPP;
 256         }
 257
 258         return 0;
 259 }
 260
 261 static int sja1000_get_state(struct net_device *dev, enum can_state *state)
 262 {
 263         struct sja1000_priv *priv = netdev_priv(dev);
 264         u8 status;
 265
 266         /* FIXME: inspecting the status register to get the current state
 267          * is not really necessary, because state changes are handled by
 268          * in the ISR and the variable priv->can.state gets updated. The
 269          * CAN devicde interface needs fixing!
 270          */
 271
 272         spin_lock_irq(&priv->can.irq_lock);
 273
 274         if (priv->can.state == CAN_STATE_STOPPED) {
 275                 *state =  CAN_STATE_STOPPED;
 276         } else {
 277                 status = priv->read_reg(dev, REG_SR);
 278                 if (status & SR_BS)
 279                         *state = CAN_STATE_BUS_OFF;
 280                 else if (status & SR_ES) {
 281                         if (priv->read_reg(dev, REG_TXERR) > 127 ||
 282                             priv->read_reg(dev, REG_RXERR) > 127)
 283                                 *state = CAN_STATE_BUS_PASSIVE;
 284                         else
 285                                 *state = CAN_STATE_BUS_WARNING;
 286                 } else
 287                         *state = CAN_STATE_ACTIVE;
 288         }
 289 #ifdef CONFIG_CAN_DEBUG_DEVICES
 290         /* Check state */
 291         if (*state != priv->can.state)
 292                 dev_err(ND2D(dev),
 293                         "Oops, state mismatch: hard %d != soft %d\n",
 294                         *state, priv->can.state);
 295 #endif
 296         spin_unlock_irq(&priv->can.irq_lock);
 297         return 0;
 298 }
 299
 300 static int sja1000_set_bittime(struct net_device *dev, struct can_bittime *bt)
 301 {
 302         struct sja1000_priv *priv = netdev_priv(dev);
 303         u8 btr0, btr1;
 304
 305         switch (bt->type) {
 306         case CAN_BITTIME_BTR:
 307                 btr0 = bt->btr.btr0;
 308                 btr1 = bt->btr.btr1;
 309                 break;
 310
 311         case CAN_BITTIME_STD:
 312                 btr0 = ((bt->std.brp - 1) & 0x3f) |
 313                     (((bt->std.sjw - 1) & 0x3) << 6);
 314                 btr1 = ((bt->std.prop_seg +
 315                          bt->std.phase_seg1 - 1) & 0xf) |
 316                     (((bt->std.phase_seg2 - 1) & 0x7) << 4) |
 317                     ((bt->std.sam & 1) << 7);
 318                 break;
 319
 320         default:
 321                 return -EINVAL;
 322         }
 323         DBG("%s: BTR0 0x%02x BTR1 0x%02x\n", dev->name, btr0, btr1);
 324
 325         priv->write_reg(dev, REG_BTR0, btr0);
 326         priv->write_reg(dev, REG_BTR1, btr1);
 327
 328         return 0;
 329 }
 330
 331 /*
 332  * initialize SJA1000 chip:
 333  *   - reset chip
 334  *   - set output mode
 335  *   - set baudrate
 336  *   - enable interrupts
 337  *   - start operating mode
 338  */
 339 static void chipset_init(struct net_device *dev)
 340 {
 341         struct sja1000_priv *priv = netdev_priv(dev);
 342
 343         /* set clock divider and output control register */
 344         priv->write_reg(dev, REG_CDR, priv->cdr | CDR_PELICAN);
 345
 346         /* set acceptance filter (accept all) */
 347         priv->write_reg(dev, REG_ACCC0, 0x00);
 348         priv->write_reg(dev, REG_ACCC1, 0x00);
 349         priv->write_reg(dev, REG_ACCC2, 0x00);
 350         priv->write_reg(dev, REG_ACCC3, 0x00);
 351
 352         priv->write_reg(dev, REG_ACCM0, 0xFF);
 353         priv->write_reg(dev, REG_ACCM1, 0xFF);
 354         priv->write_reg(dev, REG_ACCM2, 0xFF);
 355         priv->write_reg(dev, REG_ACCM3, 0xFF);
 356
 357         priv->write_reg(dev, REG_OCR, priv->ocr | OCR_MODE_NORMAL);
 358 }
 359
 360 /*
 361  * transmit a CAN message
 362  * message layout in the sk_buff should be like this:
 363  * xx xx xx xx   ff      ll   00 11 22 33 44 55 66 77
 364  * [  can-id ] [flags] [len] [can data (up to 8 bytes]
 365  */
 366 static int sja1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
 367 {
 368         struct sja1000_priv *priv = netdev_priv(dev);
 369         struct net_device_stats *stats = dev->get_stats(dev);
 370         struct can_frame *cf = (struct can_frame *)skb->data;
 371         uint8_t fi;
 372         uint8_t dlc;
 373         canid_t id;
 374         uint8_t dreg;
 375         int i;
 376
 377         netif_stop_queue(dev);
 378
 379         fi = dlc = cf->can_dlc;
 380         id = cf->can_id;
 381
 382         if (id & CAN_RTR_FLAG)
 383                 fi |= FI_RTR;
 384
 385         if (id & CAN_EFF_FLAG) {
 386                 fi |= FI_FF;
 387                 dreg = EFF_BUF;
 388                 priv->write_reg(dev, REG_FI, fi);
 389                 priv->write_reg(dev, REG_ID1, (id & 0x1fe00000) >> (5 + 16));
 390                 priv->write_reg(dev, REG_ID2, (id & 0x001fe000) >> (5 + 8));
 391                 priv->write_reg(dev, REG_ID3, (id & 0x00001fe0) >> 5);
 392                 priv->write_reg(dev, REG_ID4, (id & 0x0000001f) << 3);
 393         } else {
 394                 dreg = SFF_BUF;
 395                 priv->write_reg(dev, REG_FI, fi);
 396                 priv->write_reg(dev, REG_ID1, (id & 0x000007f8) >> 3);
 397                 priv->write_reg(dev, REG_ID2, (id & 0x00000007) << 5);
 398         }
 399
 400         for (i = 0; i < dlc; i++)
 401                 priv->write_reg(dev, dreg++, cf->data[i]);
 402
 403         stats->tx_bytes += dlc;
 404         dev->trans_start = jiffies;
 405
 406         can_put_echo_skb(skb, dev, 0);
 407
 408         priv->write_reg(dev, REG_CMR, CMD_TR);
 409
 410         return 0;
 411 }
 412
 413 static void sja1000_rx(struct net_device *dev)
 414 {
 415         struct sja1000_priv *priv = netdev_priv(dev);
 416         struct net_device_stats *stats = dev->get_stats(dev);
 417         struct can_frame *cf;
 418         struct sk_buff *skb;
 419         uint8_t fi;
 420         uint8_t dreg;
 421         canid_t id;
 422         uint8_t dlc;
 423         int i;
 424
 425         skb = dev_alloc_skb(sizeof(struct can_frame));
 426         if (skb == NULL)
 427                 return;
 428         skb->dev = dev;
 429         skb->protocol = htons(ETH_P_CAN);
 430
 431         fi = priv->read_reg(dev, REG_FI);
 432         dlc = fi & 0x0F;
 433
 434         if (fi & FI_FF) {
 435                 /* extended frame format (EFF) */
 436                 dreg = EFF_BUF;
 437                 id = (priv->read_reg(dev, REG_ID1) << (5 + 16))
 438                     | (priv->read_reg(dev, REG_ID2) << (5 + 8))
 439                     | (priv->read_reg(dev, REG_ID3) << 5)
 440                     | (priv->read_reg(dev, REG_ID4) >> 3);
 441                 id |= CAN_EFF_FLAG;
 442         } else {
 443                 /* standard frame format (SFF) */
 444                 dreg = SFF_BUF;
 445                 id = (priv->read_reg(dev, REG_ID1) << 3)
 446                     | (priv->read_reg(dev, REG_ID2) >> 5);
 447         }
 448
 449         if (fi & FI_RTR)
 450                 id |= CAN_RTR_FLAG;
 451
 452         cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
 453         memset(cf, 0, sizeof(struct can_frame));
 454         cf->can_id = id;
 455         cf->can_dlc = dlc;
 456         for (i = 0; i < dlc; i++)
 457                 cf->data[i] = priv->read_reg(dev, dreg++);
 458
 459         while (i < 8)
 460                 cf->data[i++] = 0;
 461
 462         /* release receive buffer */
 463         priv->write_reg(dev, REG_CMR, CMD_RRB);
 464
 465         netif_rx(skb);
 466
 467         dev->last_rx = jiffies;
 468         stats->rx_packets++;
 469         stats->rx_bytes += dlc;
 470 }
 471
 472 static int sja1000_err(struct net_device *dev,
 473                        uint8_t isrc, uint8_t status, int n)
 474 {
 475         struct sja1000_priv *priv = netdev_priv(dev);
 476         struct net_device_stats *stats = dev->get_stats(dev);
 477         struct can_frame *cf;
 478         struct sk_buff *skb;
 479         enum can_state state = priv->can.state;
 480         uint8_t ecc, alc;
 481
 482         skb = dev_alloc_skb(sizeof(struct can_frame));
 483         if (skb == NULL)
 484                 return -ENOMEM;
 485         skb->dev = dev;
 486         skb->protocol = htons(ETH_P_CAN);
 487         cf = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
 488         memset(cf, 0, sizeof(struct can_frame));
 489         cf->can_id = CAN_ERR_FLAG;
 490         cf->can_dlc = CAN_ERR_DLC;
 491
 492         if (isrc & IRQ_DOI) {
 493                 /* data overrun interrupt */
 494                 iiDBG(KERN_INFO "%s: data overrun isrc=0x%02X "
 495                       "status=0x%02X\n", dev->name, isrc, status);
 496                 iDBG(KERN_INFO "%s: DOI #%d#\n", dev->name, n);
 497                 cf->can_id |= CAN_ERR_CRTL;
 498                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 499                 priv->can.can_stats.data_overrun++;
 500                 priv->write_reg(dev, REG_CMR, CMD_CDO); /* clear bit */
 501         }
 502
 503         if (isrc & IRQ_EI) {
 504                 /* error warning interrupt */
 505                 iiDBG(KERN_INFO "%s: error warning isrc=0x%02X "
 506                       "status=0x%02X\n", dev->name, isrc, status);
 507                 iDBG(KERN_INFO "%s: EI #%d#\n", dev->name, n);
 508                 priv->can.can_stats.error_warning++;
 509
 510                 if (status & SR_BS) {
 511                         state = CAN_STATE_BUS_OFF;
 512                         cf->can_id |= CAN_ERR_BUSOFF;
 513                         can_bus_off(dev);
 514                         iDBG(KERN_INFO "%s: BUS OFF\n", dev->name);
 515                 } else if (status & SR_ES) {
 516                         state = CAN_STATE_BUS_WARNING;
 517                         iDBG(KERN_INFO "%s: error\n", dev->name);
 518                 } else
 519                         state = CAN_STATE_ACTIVE;
 520         }
 521         if (isrc & IRQ_BEI) {
 522                 /* bus error interrupt */
 523                 iiDBG(KERN_INFO "%s: bus error isrc=0x%02X "
 524                       "status=0x%02X\n", dev->name, isrc, status);
 525                 iDBG(KERN_INFO "%s: BEI #%d# [%d]\n", dev->name, n,
 526                      priv->can.can_stats.bus_error);
 527                 priv->can.can_stats.bus_error++;
 528                 ecc = priv->read_reg(dev, REG_ECC);
 529                 iDBG(KERN_INFO "%s: ECC = 0x%02X (%s, %s, %s)\n",
 530                      dev->name, ecc,
 531                      (ecc & ECC_DIR) ? "RX" : "TX",
 532                      ecc_types[ecc >> ECC_ERR],
 533                      ecc_errors[ecc & ECC_SEG]);
 534
 535                 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 536
 537                 switch (ecc & ECC_MASK) {
 538                 case ECC_BIT:
 539                         cf->data[2] |= CAN_ERR_PROT_BIT;
 540                         break;
 541                 case ECC_FORM:
 542                         cf->data[2] |= CAN_ERR_PROT_FORM;
 543                         break;
 544                 case ECC_STUFF:
 545                         cf->data[2] |= CAN_ERR_PROT_STUFF;
 546                         break;
 547                 default:
 548                         cf->data[2] |= CAN_ERR_PROT_UNSPEC;
 549                         cf->data[3] = ecc & ECC_SEG;
 550                         break;
 551                 }
 552                 /* Error occured during transmission? */
 553                 if ((ecc & ECC_DIR) == 0)
 554                         cf->data[2] |= CAN_ERR_PROT_TX;
 555         }
 556         if (isrc & IRQ_EPI) {
 557                 /* error passive interrupt */
 558                 iiDBG(KERN_INFO "%s: error passive isrc=0x%02X"
 559                       " status=0x%02X\n", dev->name, isrc, status);
 560                 iDBG(KERN_INFO "%s: EPI #%d#\n", dev->name, n);
 561                 priv->can.can_stats.error_passive++;
 562                 if (status & SR_ES) {
 563                         iDBG(KERN_INFO "%s: ERROR PASSIVE\n", dev->name);
 564                         state = CAN_STATE_BUS_PASSIVE;
 565                 } else {
 566                         iDBG(KERN_INFO "%s: ERROR ACTIVE\n", dev->name);
 567                         state = CAN_STATE_ACTIVE;
 568                 }
 569         }
 570         if (isrc & IRQ_ALI) {
 571                 /* arbitration lost interrupt */
 572                 iiDBG(KERN_INFO "%s: error arbitration lost "
 573                       "isrc=0x%02X status=0x%02X\n",
 574                       dev->name, isrc, status);
 575                 iDBG(KERN_INFO "%s: ALI #%d#\n", dev->name, n);
 576                 alc = priv->read_reg(dev, REG_ALC);
 577                 iDBG(KERN_INFO "%s: ALC = 0x%02X\n", dev->name, alc);
 578                 priv->can.can_stats.arbitration_lost++;
 579                 cf->can_id |= CAN_ERR_LOSTARB;
 580                 cf->data[0] = alc & 0x1f;
 581         }
 582
 583         if (state != priv->can.state && (state == CAN_STATE_BUS_WARNING ||
 584                                          state == CAN_STATE_BUS_PASSIVE)) {
 585                 uint8_t rxerr = priv->read_reg(dev, REG_RXERR);
 586                 uint8_t txerr = priv->read_reg(dev, REG_TXERR);
 587                 cf->can_id |= CAN_ERR_CRTL;
 588                 if (state == CAN_STATE_BUS_WARNING)
 589                         cf->data[1] = (txerr > rxerr) ?
 590                                 CAN_ERR_CRTL_TX_WARNING :
 591                                 CAN_ERR_CRTL_RX_WARNING;
 592                 else
 593                         cf->data[1] = (txerr > rxerr) ?
 594                                 CAN_ERR_CRTL_TX_PASSIVE :
 595                                 CAN_ERR_CRTL_RX_PASSIVE;
 596         }
 597
 598         priv->can.state = state;
 599
 600         netif_rx(skb);
 601
 602         dev->last_rx = jiffies;
 603         stats->rx_packets++;
 604         stats->rx_bytes += cf->can_dlc;
 605
 606         return 0;
 607 }
 608
 609 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 610 static irqreturn_t sja1000_interrupt(int irq, void *dev_id,
 611                                      struct pt_regs *regs)
 612 #else
 613 static irqreturn_t sja1000_interrupt(int irq, void *dev_id)
 614 #endif
 615 {
 616         struct net_device *dev = (struct net_device *)dev_id;
 617         struct sja1000_priv *priv = netdev_priv(dev);
 618         struct net_device_stats *stats = dev->get_stats(dev);
 619         uint8_t isrc, status;
 620         int n = 0;
 621
 622         if (priv->pre_irq)
 623                 priv->pre_irq(dev);
 624
 625         iiDBG(KERN_INFO "%s: interrupt\n", dev->name);
 626
 627         if (priv->can.state == CAN_STATE_STOPPED) {
 628                 iiDBG(KERN_ERR "%s: %s: controller is in reset mode! "
 629                       "MOD=0x%02X IER=0x%02X IR=0x%02X SR=0x%02X!\n",
 630                       dev->name, __func__, priv->read_reg(dev, REG_MOD),
 631                       priv->read_reg(dev, REG_IER), priv->read_reg(dev, REG_IR),
 632                       priv->read_reg(dev, REG_SR));
 633                 goto out;
 634         }
 635
 636         while ((isrc = priv->read_reg(dev, REG_IR)) && (n < 20)) {
 637                 n++;
 638                 status = priv->read_reg(dev, REG_SR);
 639
 640                 if (isrc & IRQ_WUI) {
 641                         /* wake-up interrupt */
 642                         priv->can.can_stats.wakeup++;
 643                 }
 644                 if (isrc & IRQ_TI) {
 645                         /* transmission complete interrupt */
 646                         stats->tx_packets++;
 647                         can_get_echo_skb(dev, 0);
 648                         netif_wake_queue(dev);
 649                 }
 650                 if (isrc & IRQ_RI) {
 651                         /* receive interrupt */
 652                         while (status & SR_RBS) {
 653                                 sja1000_rx(dev);
 654                                 status = priv->read_reg(dev, REG_SR);
 655                         }
 656                 }
 657                 if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) {
 658                         /* error interrupt */
 659                         if (sja1000_err(dev, isrc, status, n))
 660                                 break;
 661                 }
 662         }
 663         if (n > 1)
 664                 iDBG(KERN_INFO "%s: handled %d IRQs\n", dev->name, n);
 665
 666 out:
 667         if (priv->post_irq)
 668                 priv->post_irq(dev);
 669
 670         return n == 0 ? IRQ_NONE : IRQ_HANDLED;
 671 }
 672
 673 static int sja1000_open(struct net_device *dev)
 674 {
 675         struct sja1000_priv *priv = netdev_priv(dev);
 676         int err;
 677
 678         /* set chip into reset mode */
 679         set_reset_mode(dev);
 680
 681         /* register interrupt handler */
 682 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 683         err = request_irq(dev->irq, &sja1000_interrupt, SA_SHIRQ,
 684                           dev->name, (void *)dev);
 685 #else
 686         err = request_irq(dev->irq, &sja1000_interrupt, IRQF_SHARED,
 687                           dev->name, (void *)dev);
 688 #endif
 689         if (err)
 690                 return -EAGAIN;
 691
 692 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 693         /* clear statistics */
 694         memset(&priv->can.net_stats, 0, sizeof(priv->can.net_stats));
 695 #endif
 696
 697         /* init and start chi */
 698         sja1000_start(dev);
 699         priv->open_time = jiffies;
 700
 701         netif_start_queue(dev);
 702
 703         return 0;
 704 }
 705
 706 static int sja1000_close(struct net_device *dev)
 707 {
 708         struct sja1000_priv *priv = netdev_priv(dev);
 709
 710         set_reset_mode(dev);
 711         netif_stop_queue(dev);
 712         priv->open_time = 0;
 713         can_close_cleanup(dev);
 714         free_irq(dev->irq, (void *)dev);
 715
 716         return 0;
 717 }
 718
 719 struct net_device *alloc_sja1000dev(int sizeof_priv)
 720 {
 721         struct net_device *dev;
 722         struct sja1000_priv *priv;
 723
 724         dev = alloc_candev(sizeof(struct sja1000_priv) + sizeof_priv);
 725         if (!dev)
 726                 return NULL;
 727
 728         priv = netdev_priv(dev);
 729         priv->dev = dev;
 730
 731         if (sizeof_priv)
 732                 priv->priv = (void *)priv + sizeof(struct sja1000_priv);
 733
 734         return dev;
 735 }
 736 EXPORT_SYMBOL_GPL(alloc_sja1000dev);
 737
 738 void free_sja1000dev(struct net_device *dev)
 739 {
 740         free_candev(dev);
 741 }
 742 EXPORT_SYMBOL(free_sja1000dev);
 743
 744 int register_sja1000dev(struct net_device *dev)
 745 {
 746         struct sja1000_priv *priv = netdev_priv(dev);
 747         int err;
 748
 749         if (!sja1000_probe_chip(dev))
 750                 return -ENODEV;
 751
 752         dev->flags |= IFF_ECHO; /* we support local echo */
 753
 754         dev->open = sja1000_open;
 755         dev->stop = sja1000_close;
 756
 757         dev->hard_start_xmit = sja1000_start_xmit;
 758
 759         priv->can.do_set_bittime = sja1000_set_bittime;
 760         priv->can.do_get_state = sja1000_get_state;
 761         priv->can.do_set_mode = sja1000_set_mode;
 762         priv->dev = dev;
 763
 764         err = register_netdev(dev);
 765         if (err) {
 766                 printk(KERN_INFO
 767                        "%s: registering netdev failed\n", CHIP_NAME);
 768                 free_netdev(dev);
 769                 return err;
 770         }
 771
 772         set_reset_mode(dev);
 773         chipset_init(dev);
 774         return 0;
 775 }
 776 EXPORT_SYMBOL(register_sja1000dev);
 777
 778 void unregister_sja1000dev(struct net_device *dev)
 779 {
 780         set_reset_mode(dev);
 781         unregister_netdev(dev);
 782 }
 783 EXPORT_SYMBOL(unregister_sja1000dev);
 784
 785 static __init int sja1000_init(void)
 786 {
 787         printk(KERN_INFO "%s driver v%s (%s)\n",
 788                drv_name, drv_version, drv_reldate);
 789         printk(KERN_INFO "%s - options [debug %d]\n", drv_name, debug);
 790         printk(KERN_INFO "%s driver %s %s loaded\n",
 791                drv_name, drv_version, drv_reldate);
 792         return 0;
 793 }
 794
 795 module_init(sja1000_init);
 796
 797 static __exit void sja1000_exit(void)
 798 {
 799         printk(KERN_INFO "%s driver %s %s unloaded\n",
 800                drv_name, drv_version, drv_reldate);
 801 }
 802
 803 module_exit(sja1000_exit);