kernel/2.6/drivers/net/can/esd_pci331.c

   1 /*
   2  * Copyright (C) 2009 Thomas Koerper <thomas.koerper@esd.eu>, esd gmbh
   3  * derived from kernel/2.6/drivers/net/can/sja1000/esd_pci.c,
   4  * * Copyright (C) 2007 Wolfgang Grandegger <wg@grandegger.com>
   5  * * Copyright (C) 2008 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
   6  * * Copyright (C) 2009 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
   7  * and kernel/2.6/drivers/net/can/at91_can.c,
   8  * * Copyright (C) 2007 by Hans J. Koch <hjk@linutronix.de>
   9  * * Copyright (C) 2008 by Marc Kleine-Budde <kernel@pengutronix.de
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the version 2 of the GNU General Public License
  13  * as published by the Free Software Foundation
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include <linux/interrupt.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/module.h>
  28 #include <linux/kernel.h>
  29 #include <linux/if_arp.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/types.h>
  32 #include <linux/delay.h>
  33 #include <linux/errno.h>
  34 #include <linux/init.h>
  35 #include <linux/io.h>
  36 #include <linux/byteorder/generic.h>
  37 #include <linux/pci.h>
  38 #include <linux/pci_ids.h>
  39 #include <socketcan/can.h>
  40 #include <socketcan/can/error.h>
  41 #include <socketcan/can/dev.h>
  42
  43 #define DRV_NAME "esd_pci331"
  44
  45 MODULE_AUTHOR("Thomas Koerper <thomas.koerper@esd.eu>");
  46 MODULE_LICENSE("GPL v2");
  47 MODULE_DESCRIPTION("Socket-CAN driver for the esd 331 CAN cards");
  48 MODULE_DEVICE_TABLE(pci, esd331_pci_tbl);
  49 MODULE_SUPPORTED_DEVICE("esd CAN-PCI/331, CAN-CPCI/331, CAN-PMC/331");
  50
  51 #ifndef PCI_DEVICE_ID_PLX_9030
  52 # define PCI_DEVICE_ID_PLX_9030 0x9030
  53 #endif
  54 #ifndef PCI_DEVICE_ID_PLX_9050
  55 # define PCI_DEVICE_ID_PLX_9050 0x9050
  56 #endif
  57 #ifndef PCI_VENDOR_ID_ESDGMBH
  58 #define PCI_VENDOR_ID_ESDGMBH   0x12fe
  59 #endif
  60
  61 #define ESD_PCI_SUB_SYS_ID_PCI331 0x0001
  62 #define ESD_PCI_SUB_SYS_ID_PMC331 0x000C
  63
  64 /* Maximum number of interfaces supported per card */
  65 #define ESD331_MAX_CAN                  2
  66 /* 331's fifo size. Don't change! */
  67 #define ESD331_DPRSIZE                  1024
  68 /* Max. messages to handle per interrupt */
  69 #define ESD331_MAX_INTERRUPT_WORK       8
  70 #define ESD331_MAX_BOARD_MESSAGES       5
  71 #define ESD331_RTR_FLAG                 0x10
  72 #define ESD331_ERR_OK                   0x00
  73 #define ESD331_ERR_WARN                 0x40
  74 #define ESD331_ERR_BUSOFF1              0x80
  75 #define ESD331_ERR_BUSOFF2              0xc0
  76 #define ESD331_CONF_OFFS_ICS            0x4c
  77 #define ESD331_CONF_OFFS_MISC_CTRL      0x50
  78 #define ESD331_OFFS_LINK_BASE           0x846
  79 #define ESD331_OFFS_IRQ_ACK             0xc0100
  80 #define ESD331_NETS_MASK                0x07
  81 #define ESD331_EVENT_MASK               0x7f
  82 #define ESD331_DLC_MASK                 0x0f
  83 #define ESD331_EFF_SUPP_FLAG            0x80
  84 #define ESD331_IRQ_FLAG                 0x00000004
  85 #define ESD331_ENABLE_IRQ_FLAG          0x00000041
  86 #define ESD331_STOP_OS                  0x40000010
  87 #define ESD331_RESTART_OS               0x40000028
  88
  89 #define ESD331_I20_BCAN                 0
  90 #define ESD331_I20_ENABLE               1
  91 #define ESD331_I20_BAUD                 4
  92 #define ESD331_I20_TXDONE               5
  93 #define ESD331_I20_TXTOUT               12
  94 #define ESD331_I20_ERROR                13
  95 #define ESD331_I20_BOARD                14
  96 #define ESD331_I20_EX_BCAN              15
  97 #define ESD331_I20_EX_TXDONE            16
  98 #define ESD331_I20_EX_TXTOUT            17
  99 #define ESD331_I20_BOARD2               20
 100 #define ESD331_I20_FAST                 21
 101
 102 static struct pci_device_id esd331_pci_tbl[] = {
 103         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 104         PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI331},
 105         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
 106         PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PMC331},
 107         {0, }
 108 };
 109
 110 struct esd331_can_msg {
 111         u8 cmmd;
 112         u8 net;
 113         s16 id;
 114         s16 len;
 115         u8 data[8];
 116         u16 x1;
 117         u16 x2;
 118         u16 x3;
 119 } __attribute__((packed));
 120 #define ESD331_CM_SSIZE (sizeof(struct esd331_can_msg) / sizeof(u16))
 121
 122 struct esd331_idp {
 123         u8 dummy[16];
 124         u8 buffer[4];
 125 } __attribute__((packed));
 126
 127 struct esd331_dpr {
 128         char magic[16];
 129         u16 rx_in;
 130         u16 dummy1;
 131         u16 rx_ou;
 132         u16 dummy2;
 133         struct esd331_can_msg rx_buff[ESD331_DPRSIZE];
 134         u16 tx_in;
 135         u16 dummy3;
 136         u16 tx_ou;
 137         u16 dummy4;
 138         struct esd331_can_msg tx_buff[ESD331_DPRSIZE];
 139 } __attribute__((packed));
 140
 141 struct esd331_pci {
 142         struct pci_dev *pci_dev;
 143         struct net_device *dev[ESD331_MAX_CAN];
 144         void __iomem *conf_addr;
 145         void __iomem *base_addr1;
 146         void __iomem *base_addr2;
 147         spinlock_t irq_lock; /* locks access to card's fifo */
 148         struct esd331_dpr *dpr;
 149         int eff_supp;
 150         int net_count;
 151 };
 152
 153 struct esd331_priv {
 154         struct can_priv can; /* must be the first member! */
 155         struct esd331_pci *board;
 156         u8 boards_net;
 157 };
 158
 159 struct esd331_baud_entry {
 160         u32 rate;
 161         u16 index;
 162 };
 163
 164 static struct esd331_baud_entry esd331_baud_table[] = {
 165         {1600000, 15},
 166         {1000000, 0},
 167         {800000, 14},
 168         {666666, 1},
 169         {500000, 2},
 170         {333333, 3},
 171         {250000, 4},
 172         {166666, 5},
 173         {125000, 6},
 174         {100000, 7},
 175         {83333, 16},
 176         {66666, 8},
 177         {50000, 9},
 178         {33333, 10},
 179         {20000, 11},
 180         {12500, 12},
 181         {10000, 13}
 182 };
 183
 184 static void esd331_reset(void *pci331_confspace, int wait_for_restart)
 185 {
 186         unsigned long data;
 187         void __iomem *addr = pci331_confspace + ESD331_CONF_OFFS_MISC_CTRL;
 188
 189         data = readl(addr);
 190         data |= ESD331_STOP_OS;
 191         writel(data, addr);
 192         msleep(10);
 193
 194         data = readl(addr);
 195         data &= ~ESD331_RESTART_OS;
 196         writel(data, addr);
 197
 198         if (wait_for_restart)
 199                 msleep_interruptible(3500);
 200 }
 201
 202 static struct esd331_dpr *esd331_init_pointer(void __iomem *pci331_space2)
 203 {
 204         unsigned long data;
 205         struct esd331_idp *idp;
 206         void __iomem *ptr = pci331_space2 + ESD331_OFFS_LINK_BASE;
 207
 208         data = readb(ptr++);
 209         data = (data << 8) + readb(ptr++);
 210         data = (data << 8) + readb(ptr++);
 211         data = (data << 8) + readb(ptr++);
 212
 213         idp = (struct esd331_idp *)(pci331_space2 + data);
 214         data = idp->buffer[0];
 215         data = (data << 8) + idp->buffer[1];
 216         data = (data << 8) + idp->buffer[2];
 217         data = (data << 8) + idp->buffer[3];
 218
 219         return (struct esd331_dpr *)(pci331_space2 + data);
 220 }
 221
 222 static void esd331_enable_irq(void *pci331_confspace)
 223 {
 224         void __iomem *addr = pci331_confspace + ESD331_CONF_OFFS_ICS;
 225         u32 data;
 226
 227         data = readl(addr);
 228         data |= ESD331_ENABLE_IRQ_FLAG;
 229         writel(data, addr);
 230 }
 231
 232 static void esd331_disable_irq(void *pci331_confspace)
 233 {
 234         void __iomem *addr = pci331_confspace + ESD331_CONF_OFFS_ICS;
 235         u32 data;
 236
 237         data = readl(addr);
 238         data &= ~ESD331_ENABLE_IRQ_FLAG;
 239         writel(data, addr);
 240 }
 241
 242 static int esd331_write(struct esd331_can_msg *mesg, struct esd331_pci *board)
 243 {
 244         u16 in;
 245         u16 in_new;
 246         u16 out;
 247         unsigned long irq_flags;
 248         int err = -EAGAIN; /* = card's fifo full */
 249         int i;
 250
 251         spin_lock_irqsave(&board->irq_lock, irq_flags);
 252
 253         out = be16_to_cpu(readw(&board->dpr->rx_ou));
 254         in = be16_to_cpu(readw(&board->dpr->rx_in));
 255
 256         in_new = (in + 1) % ESD331_DPRSIZE;
 257
 258         if (in_new != out) {
 259                 u16 *ptr1;
 260                 u16 *ptr2;
 261
 262                 ptr1 = (u16 *)mesg;
 263                 ptr2 = (u16 *)&board->dpr->rx_buff[in];
 264                 for (i = 0; i < ESD331_CM_SSIZE; i++)
 265                         writew(*ptr1++, ptr2++);
 266
 267                 in_new = cpu_to_be16(in_new);
 268                 wmb();
 269                 writew(in_new, &board->dpr->rx_in);
 270
 271                 err = 0;
 272         }
 273
 274         spin_unlock_irqrestore(&board->irq_lock, irq_flags);
 275         return err;
 276 }
 277
 278 static int esd331_read(struct esd331_can_msg *mesg, struct esd331_pci *board)
 279 {
 280         u16 in;
 281         u16 out;
 282         unsigned long irq_flags;
 283         int err = -ENODATA;
 284
 285         spin_lock_irqsave(&board->irq_lock, irq_flags);
 286
 287         out = be16_to_cpu(readw(&board->dpr->tx_ou));
 288         in = be16_to_cpu(readw(&board->dpr->tx_in));
 289
 290         if (in != out) {
 291                 u16 *ptr1;
 292                 u16 *ptr2;
 293                 int ll;
 294
 295                 ptr1 = (u16 *)mesg;
 296                 ptr2 = (u16 *)&board->dpr->tx_buff[out];
 297                 for (ll = 0; ll < ESD331_CM_SSIZE; ll++)
 298                         *ptr1++ = readw(ptr2++);
 299
 300                 out++;
 301                 out %= ESD331_DPRSIZE;
 302
 303                 wmb();
 304                 writew(cpu_to_be16(out), &board->dpr->tx_ou);
 305
 306                 mesg->id = be16_to_cpu(mesg->id);
 307                 mesg->len = be16_to_cpu(mesg->len);
 308                 mesg->x1 = be16_to_cpu(mesg->x1);
 309                 mesg->x2 = be16_to_cpu(mesg->x2);
 310                 mesg->x3 = be16_to_cpu(mesg->x3);
 311
 312                 err = 0;
 313         }
 314
 315         spin_unlock_irqrestore(&board->irq_lock, irq_flags);
 316         return err;
 317 }
 318
 319 static int esd331_send(struct esd331_pci *board, u8 pci331net, unsigned long id,
 320                         int eff, int rtr, u16 dlc, u8 *data)
 321 {
 322         struct esd331_can_msg msg;
 323         int i;
 324
 325         memset(&msg, 0, sizeof(msg));
 326
 327         if (eff) {
 328                 msg.cmmd = ESD331_I20_EX_BCAN;
 329                 msg.id = cpu_to_be16((id >> 16) & 0x1fff);
 330                 msg.x2 = cpu_to_be16(id);
 331         } else {
 332                 msg.cmmd = ESD331_I20_BCAN;
 333                 msg.id = cpu_to_be16(id);
 334         }
 335         msg.net = pci331net;
 336         msg.len = cpu_to_be16(rtr ? dlc | ESD331_RTR_FLAG : dlc);
 337
 338         i = (dlc < 8) ? dlc : 8;
 339         while (i--)
 340                 msg.data[i] = data[i];
 341
 342         return esd331_write(&msg, board);
 343 }
 344
 345 static int esd331_write_allid(u8 net, struct esd331_pci *board)
 346 {
 347         struct esd331_can_msg mesg;
 348         u16 id;
 349
 350         memset(&mesg, 0, sizeof(mesg));
 351
 352         mesg.cmmd = ESD331_I20_ENABLE;
 353         mesg.net = net;
 354
 355         for (id = 0; id < 2048; id++) {
 356                 int retryCount = 5;
 357
 358                 mesg.id = cpu_to_be16(id);
 359
 360                 while (esd331_write(&mesg, board) && (retryCount--))
 361                         msleep(1);
 362
 363                 if (retryCount == 0)
 364                         return -EIO;
 365         }
 366
 367         return 0;
 368 }
 369
 370 static int esd331_write_fast(struct esd331_pci *board)
 371 {
 372         struct esd331_can_msg mesg;
 373
 374         memset(&mesg, 0, sizeof(mesg));
 375         mesg.cmmd = ESD331_I20_FAST;
 376
 377         return esd331_write(&mesg, board);
 378 }
 379
 380 static int esd331_write_baud(u8 pci331net, int index, struct esd331_pci *board)
 381 {
 382         struct esd331_can_msg mesg;
 383
 384         memset(&mesg, 0, sizeof(mesg));
 385         mesg.cmmd = ESD331_I20_BAUD;
 386         mesg.net = pci331net;
 387         mesg.data[0] = (u8)(index >> 8);
 388         mesg.data[1] = (u8)index;
 389
 390         return esd331_write(&mesg, board);
 391 }
 392
 393 static int esd331_read_features(struct esd331_pci *board)
 394 {
 395         struct esd331_can_msg msg;
 396         int max_msg = ESD331_MAX_BOARD_MESSAGES;
 397
 398         board->net_count = 0;
 399         board->eff_supp = 0;
 400
 401         while ((esd331_read(&msg, board) == 0) && (max_msg--)) {
 402                 if (msg.cmmd == ESD331_I20_BOARD) {
 403                         u8 magic = (msg.x1 >> 8);
 404
 405                         if (magic == 0) {
 406                                 u8 features = (u8)msg.x1;
 407                                 u8 nets = (features & ESD331_NETS_MASK);
 408
 409                                 if (nets <= ESD331_MAX_CAN)
 410                                         board->net_count = nets;
 411
 412                                 if (features & ESD331_EFF_SUPP_FLAG)
 413                                         board->eff_supp = 1;
 414                         }
 415                 } else if (msg.cmmd == ESD331_I20_BOARD2) {
 416                         u8 features = msg.net;
 417
 418                         if (features & ESD331_EFF_SUPP_FLAG)
 419                                 board->eff_supp = 1;
 420
 421                         if (board->net_count == 0) {
 422                                 u8 nets = (features & ESD331_NETS_MASK);
 423
 424                                 if (nets <= ESD331_MAX_CAN)
 425                                         board->net_count = nets;
 426                         }
 427                 }
 428         }
 429
 430         return (board->net_count < 1) ? -EIO : 0;
 431 }
 432
 433 static int esd331_create_err_frame(struct net_device *dev, canid_t idflags,
 434                                         u8 d1)
 435 {
 436         struct net_device_stats *stats;
 437         struct can_frame *cf;
 438         struct sk_buff *skb;
 439
 440         skb = dev_alloc_skb(sizeof(*cf));
 441         if (unlikely(skb == NULL))
 442                 return -ENOMEM;
 443
 444 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 445         stats = can_get_stats(dev);
 446 #else
 447         stats = &dev->stats;
 448 #endif
 449
 450         skb->dev = dev;
 451         skb->protocol = htons(ETH_P_CAN);
 452         cf = (struct can_frame *)skb_put(skb, sizeof(*cf));
 453         memset(cf, 0, sizeof(*cf));
 454
 455         cf->can_id = CAN_ERR_FLAG | idflags;
 456         cf->can_dlc = CAN_ERR_DLC;
 457         cf->data[1] = d1;
 458
 459         netif_rx(skb);
 460
 461 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)
 462         dev->last_rx = jiffies;
 463 #endif
 464         stats->rx_packets++;
 465         stats->rx_bytes += cf->can_dlc;
 466
 467         return 0;
 468 }
 469
 470 static void esd331_irq_rx(struct net_device *dev, struct esd331_can_msg *msg,
 471                                 int eff)
 472 {
 473 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 474         struct net_device_stats *stats = can_get_stats(dev);
 475 #else
 476         struct net_device_stats *stats = &dev->stats;
 477 #endif
 478         struct can_frame *cfrm;
 479         struct sk_buff *skb;
 480         int i;
 481
 482         skb = netdev_alloc_skb(dev, sizeof(*cfrm));
 483         if (unlikely(skb == NULL)) {
 484                 stats->rx_dropped++;
 485                 return;
 486         }
 487         skb->protocol = htons(ETH_P_CAN);
 488
 489         cfrm = (struct can_frame *)skb_put(skb, sizeof(*cfrm));
 490         memset(cfrm, 0, sizeof(*cfrm));
 491
 492         if (eff) {
 493                 cfrm->can_id = (msg->id << 16);
 494                 cfrm->can_id |= (msg->x2);
 495         } else {
 496                 cfrm->can_id = msg->id;
 497         }
 498         if (msg->len & ESD331_RTR_FLAG)
 499                 cfrm->can_id |= CAN_RTR_FLAG;
 500
 501         if (eff)
 502                 cfrm->can_id |= CAN_EFF_FLAG;
 503
 504         cfrm->can_dlc = msg->len & ESD331_DLC_MASK;
 505
 506         if (cfrm->can_dlc > 8)
 507                 cfrm->can_dlc = 8;
 508
 509         for (i = 0; i < cfrm->can_dlc; ++i)
 510                 cfrm->data[i] = msg->data[i];
 511
 512         netif_rx(skb);
 513
 514 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)
 515         dev->last_rx = jiffies;
 516 #endif
 517         stats->rx_packets++;
 518         stats->rx_bytes += cfrm->can_dlc;
 519 }
 520
 521 static void esd331_handle_errmsg(struct net_device *dev,
 522                                         struct esd331_can_msg *msg)
 523 {
 524         struct esd331_priv *priv = netdev_priv(dev);
 525
 526         if (msg->id & ESD331_EVENT_MASK)
 527                 return;
 528
 529         switch (msg->data[1]) {
 530         case ESD331_ERR_OK:
 531                 if (priv->can.state != CAN_STATE_STOPPED)
 532                         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 533                 break;
 534
 535         case ESD331_ERR_WARN:
 536                 if ((priv->can.state != CAN_STATE_ERROR_WARNING)
 537                                 && (priv->can.state != CAN_STATE_STOPPED)) {
 538                         priv->can.can_stats.error_warning++;
 539                         priv->can.state = CAN_STATE_ERROR_WARNING;
 540
 541                         /* might be RX warning, too... */
 542                         esd331_create_err_frame(dev, CAN_ERR_CRTL,
 543                                                 CAN_ERR_CRTL_TX_WARNING);
 544                 }
 545                 break;
 546
 547         case ESD331_ERR_BUSOFF1:
 548         case ESD331_ERR_BUSOFF2:
 549                 if ((priv->can.state != CAN_STATE_BUS_OFF)
 550                                 && (priv->can.state != CAN_STATE_STOPPED)) {
 551                         priv->can.state = CAN_STATE_BUS_OFF;
 552                         esd331_create_err_frame(dev, CAN_ERR_BUSOFF, 0);
 553                         can_bus_off(dev);
 554                 }
 555                 break;
 556
 557         default:
 558                 break;
 559         }
 560
 561 }
 562
 563 static void esd331_handle_messages(struct esd331_pci *board)
 564 {
 565         struct net_device *dev;
 566         struct esd331_priv *priv;
 567         struct net_device_stats *stats;
 568         struct esd331_can_msg msg;
 569         int msg_count = ESD331_MAX_INTERRUPT_WORK;
 570
 571         while ((esd331_read(&msg, board) == 0) && (msg_count--)) {
 572                 if (unlikely((msg.net >= ESD331_MAX_CAN)
 573                                 || (board->dev[msg.net] == NULL)))
 574                         continue;
 575
 576                 dev = board->dev[msg.net];
 577                 priv = netdev_priv(dev);
 578                 if (priv->can.state == CAN_STATE_STOPPED)
 579                         continue;
 580
 581 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 582                 stats = can_get_stats(dev);
 583 #else
 584                 stats = &dev->stats;
 585 #endif
 586                 switch (msg.cmmd) {
 587
 588                 case ESD331_I20_BCAN:
 589                 case ESD331_I20_EX_BCAN:
 590                         esd331_irq_rx(dev, &msg,
 591                                         (msg.cmmd == ESD331_I20_EX_BCAN));
 592                         break;
 593
 594                 case ESD331_I20_TXDONE:
 595                 case ESD331_I20_EX_TXDONE:
 596                         stats->tx_packets++;
 597                         can_get_echo_skb(dev, 0);
 598                         netif_wake_queue(dev);
 599                         break;
 600
 601                 case ESD331_I20_TXTOUT:
 602                 case ESD331_I20_EX_TXTOUT:
 603                         stats->tx_errors++;
 604                         stats->tx_dropped++;
 605                         can_free_echo_skb(dev, 0);
 606                         netif_wake_queue(dev);
 607                         break;
 608
 609                 case ESD331_I20_ERROR:
 610                         esd331_handle_errmsg(dev, &msg);
 611                         break;
 612
 613                 default:
 614                         break;
 615                 }
 616         }
 617 }
 618
 619 static int esd331_all_nets_stopped(struct esd331_pci *board)
 620 {
 621         int i;
 622
 623         for (i = 0; i < ESD331_MAX_CAN; i++) {
 624                 if (board->dev[i] == NULL) {
 625                         break;
 626                 } else {
 627                         struct esd331_priv *priv = netdev_priv(board->dev[i]);
 628
 629                         if (priv->can.state != CAN_STATE_STOPPED)
 630                                 return 0;
 631                 }
 632         }
 633
 634         return 1;
 635 }
 636
 637 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 638 irqreturn_t esd331_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 639 #else
 640 irqreturn_t esd331_interrupt(int irq, void *dev_id)
 641 #endif
 642 {
 643         struct esd331_pci *board = (struct esd331_pci *)dev_id;
 644         void __iomem *ics = board->conf_addr + ESD331_CONF_OFFS_ICS;
 645
 646         if (!(readl(ics) & ESD331_IRQ_FLAG))
 647                 return IRQ_NONE;
 648
 649         writew(0xffff, board->base_addr2 + ESD331_OFFS_IRQ_ACK);
 650         esd331_handle_messages(board);
 651
 652         return IRQ_HANDLED;
 653 }
 654
 655 /* also enables interrupt when no other net on card is openened yet */
 656 static int esd331_open(struct net_device *dev)
 657 {
 658         struct esd331_priv *priv = netdev_priv(dev);
 659         int err;
 660
 661         err = open_candev(dev);
 662         if (err)
 663                 return err;
 664
 665 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 666         memset(&priv->can.net_stats, 0, sizeof(priv->can.net_stats));
 667 #endif
 668
 669         if (esd331_all_nets_stopped(priv->board))
 670                 esd331_enable_irq(priv->board->conf_addr);
 671
 672         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 673         netif_start_queue(dev);
 674
 675         return 0;
 676 }
 677
 678 /* also disables interrupt when all other nets on card are closed already*/
 679 static int esd331_close(struct net_device *dev)
 680 {
 681         struct esd331_priv *priv = netdev_priv(dev);
 682
 683         priv->can.state = CAN_STATE_STOPPED;
 684         netif_stop_queue(dev);
 685         close_candev(dev);
 686
 687         if (esd331_all_nets_stopped(priv->board))
 688                 esd331_disable_irq(priv->board->conf_addr);
 689
 690         return 0;
 691 }
 692
 693 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)
 694 static int esd331_start_xmit(struct sk_buff *skb, struct net_device *dev)
 695 #else
 696 static netdev_tx_t esd331_start_xmit(struct sk_buff *skb,
 697                                         struct net_device *dev)
 698 #endif
 699 {
 700         struct esd331_priv *priv = netdev_priv(dev);
 701 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 702         struct net_device_stats *stats = can_get_stats(dev);
 703 #else
 704         struct net_device_stats *stats = &dev->stats;
 705 #endif
 706         struct can_frame *cf = (struct can_frame *)skb->data;
 707         int err;
 708
 709         can_put_echo_skb(skb, dev, 0);
 710
 711         if ((cf->can_id & CAN_EFF_FLAG) && (priv->board->eff_supp == 0)) {
 712                 stats->tx_errors++;
 713                 stats->tx_dropped++;
 714                 can_free_echo_skb(dev, 0);
 715                 err = -EOPNOTSUPP;
 716                 goto out;
 717         }
 718
 719         err = esd331_send(priv->board, priv->boards_net,
 720                                 cf->can_id & CAN_EFF_MASK,
 721                                 cf->can_id & CAN_EFF_FLAG,
 722                                 cf->can_id & CAN_RTR_FLAG,
 723                                 cf->can_dlc, cf->data);
 724         if (err) {
 725                 stats->tx_fifo_errors++;
 726                 stats->tx_errors++;
 727                 stats->tx_dropped++;
 728                 can_free_echo_skb(dev, 0);
 729                 goto out;
 730         }
 731
 732         netif_stop_queue(dev);
 733         stats->tx_bytes += cf->can_dlc;
 734         dev->trans_start = jiffies;
 735 out:
 736         return err;
 737 }
 738
 739 static int esd331_set_bittiming(struct net_device *dev)
 740 {
 741         struct esd331_priv *priv = netdev_priv(dev);
 742         int i;
 743
 744         for (i = 0; i < ARRAY_SIZE(esd331_baud_table); i++) {
 745                 if (priv->can.bittiming.bitrate == esd331_baud_table[i].rate) {
 746                         return esd331_write_baud(priv->boards_net,
 747                                 esd331_baud_table[i].index, priv->board);
 748                 }
 749         }
 750
 751         return -EINVAL;
 752 }
 753
 754 static int esd331_set_mode(struct net_device *dev, enum can_mode mode)
 755 {
 756         struct esd331_priv *priv = netdev_priv(dev);
 757
 758         switch (mode) {
 759         case CAN_MODE_START:
 760                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
 761                 if (netif_queue_stopped(dev))
 762                         netif_wake_queue(dev);
 763
 764                 break;
 765
 766         default:
 767                 return -EOPNOTSUPP;
 768         }
 769
 770         return 0;
 771 }
 772
 773 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 774 static const struct net_device_ops esd331_netdev_ops = {
 775         .ndo_open = esd331_open,
 776         .ndo_stop = esd331_close,
 777         .ndo_start_xmit = esd331_start_xmit,
 778 };
 779 #endif
 780
 781 static struct net_device *__devinit esd331_pci_add_chan(struct pci_dev *pdev,
 782                 struct esd331_pci *board, u8 boards_net)
 783 {
 784         struct net_device *dev;
 785         struct esd331_priv *priv;
 786         int err;
 787
 788         dev = alloc_candev(sizeof(*priv));
 789         if (dev == NULL)
 790                 return ERR_PTR(-ENOMEM);
 791
 792         priv = netdev_priv(dev);
 793         priv->boards_net = boards_net;
 794         priv->board = board;
 795
 796         SET_NETDEV_DEV(dev, &pdev->dev);
 797
 798 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 799         dev->netdev_ops = &esd331_netdev_ops;
 800 #else
 801         dev->open = esd331_open;
 802         dev->stop = esd331_close;
 803         dev->hard_start_xmit = esd331_start_xmit;
 804 #endif
 805
 806         dev->irq = pdev->irq;
 807         /* Set and enable PCI interrupts */
 808         dev->flags |= IFF_ECHO;
 809
 810         priv->can.do_set_bittiming = esd331_set_bittiming;
 811         priv->can.do_set_mode = esd331_set_mode;
 812
 813         err = register_candev(dev);
 814         if (err) {
 815                 dev_err(&pdev->dev, "registering candev failed\n");
 816                 free_netdev(dev);
 817                 return ERR_PTR(err);
 818         }
 819
 820         dev_info(&pdev->dev, "device %s registered\n", dev->name);
 821
 822         return dev;
 823 }
 824
 825 static int __devinit esd331_pci_init_one(struct pci_dev *pdev,
 826                 const struct pci_device_id *ent)
 827 {
 828         struct esd331_pci *board;
 829         int err;
 830         int i;
 831         int read_features = 0;
 832
 833         dev_info(&pdev->dev,
 834                         "Initializing device %04x:%04x %04x:%04x\n",
 835                         pdev->vendor, pdev->device,
 836                         pdev->subsystem_vendor, pdev->subsystem_device);
 837
 838         board = kzalloc(sizeof(*board), GFP_KERNEL);
 839         if (board == NULL)
 840                 return -ENOMEM;
 841
 842         err = pci_enable_device(pdev);
 843         if (err)
 844                 goto failure;
 845
 846         err = pci_request_regions(pdev, DRV_NAME);
 847         if (err)
 848                 goto failure;
 849
 850         board->conf_addr = pci_iomap(pdev, 0, 0);
 851         if (board->conf_addr == NULL) {
 852                 err = -ENODEV;
 853                 goto failure_release_pci;
 854         }
 855         board->base_addr1 = pci_iomap(pdev, 2, 0);
 856         if (board->base_addr1 == NULL) {
 857                 err = -ENODEV;
 858                 goto failure_iounmap_conf;
 859         }
 860         board->base_addr2 = pci_iomap(pdev, 3, 0);
 861         if (board->base_addr2 == NULL) {
 862                 err = -ENODEV;
 863                 goto failure_iounmap_base1;
 864         }
 865
 866         spin_lock_init(&board->irq_lock);
 867
 868 retry_features:
 869         board->dpr = esd331_init_pointer(board->base_addr1);
 870         err = esd331_read_features(board);
 871         if (err) {
 872                 /* esd331_read_features() works only after board reset */
 873                 /* So if failed: reset board and retry: */
 874                 if (!read_features) {
 875                         read_features++;
 876                         esd331_reset(board->conf_addr, 1);
 877                         goto retry_features;
 878                 }
 879
 880                 goto failure_iounmap_base2;
 881         }
 882
 883         for (i = 0; i < board->net_count; ++i) {
 884                 board->dev[i] = esd331_pci_add_chan(pdev, board, i);
 885                 if (IS_ERR(board->dev[i])) {
 886                         err = (int)board->dev[i];
 887                         goto failure_iounmap_base2;
 888                 }
 889                 if (esd331_write_allid(i, board)) {
 890                         dev_err(&pdev->dev, "device %s failed to enable all "
 891                                                 "IDs\n", board->dev[i]->name);
 892                 }
 893         }
 894
 895         if (esd331_write_fast(board))
 896                 dev_err(&pdev->dev, "failed to enable fast mode\n");
 897
 898 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 899         err = request_irq(pdev->irq, &esd331_interrupt, SA_SHIRQ, "pci331",
 900                         (void *)board);
 901 #else
 902         err = request_irq(pdev->irq, &esd331_interrupt, IRQF_SHARED, "pci331",
 903                         (void *)board);
 904 #endif
 905         if (err) {
 906                 err = -EAGAIN;
 907                 goto failure_iounmap_base2;
 908         }
 909         pci_set_drvdata(pdev, board);
 910         return 0;
 911
 912 failure_iounmap_base2:
 913         pci_iounmap(pdev, board->base_addr2);
 914
 915 failure_iounmap_base1:
 916         pci_iounmap(pdev, board->base_addr1);
 917
 918 failure_iounmap_conf:
 919         pci_iounmap(pdev, board->conf_addr);
 920
 921 failure_release_pci:
 922         pci_release_regions(pdev);
 923
 924 failure:
 925         kfree(board);
 926
 927         return err;
 928 }
 929
 930 static void __devexit esd331_pci_remove_one(struct pci_dev *pdev)
 931 {
 932         struct esd331_pci *board = pci_get_drvdata(pdev);
 933         int i;
 934
 935         esd331_disable_irq(board->conf_addr);
 936         free_irq(pdev->irq, (void *)board);
 937
 938         for (i = 0; i < ESD331_MAX_CAN; i++) {
 939                 if (board->dev[i] == NULL)
 940                         break;
 941
 942                 unregister_candev(board->dev[i]);
 943                 free_netdev(board->dev[i]);
 944         }
 945
 946         esd331_reset(board->conf_addr, 0); /* 0 = No wait for restart here */
 947         /* If module is reloaded too early, it will try a reset with waiting */
 948
 949         pci_iounmap(pdev, board->base_addr2);
 950         pci_iounmap(pdev, board->base_addr1);
 951         pci_iounmap(pdev, board->conf_addr);
 952         pci_release_regions(pdev);
 953
 954         pci_disable_device(pdev);
 955         pci_set_drvdata(pdev, NULL);
 956
 957         kfree(board);
 958 }
 959
 960 static struct pci_driver esd331_pci_driver = {
 961         .name = DRV_NAME,
 962         .id_table = esd331_pci_tbl,
 963         .probe = esd331_pci_init_one,
 964         .remove = __devexit_p(esd331_pci_remove_one), };
 965
 966 static int __init esd331_pci_init(void)
 967 {
 968         printk(KERN_INFO "%s CAN netdevice driver\n", DRV_NAME);
 969         return pci_register_driver(&esd331_pci_driver);
 970 }
 971
 972 static void __exit esd331_pci_exit(void)
 973 {
 974         pci_unregister_driver(&esd331_pci_driver);
 975         printk(KERN_INFO "%s driver removed\n", DRV_NAME);
 976 }
 977
 978 module_init(esd331_pci_init);
 979 module_exit(esd331_pci_exit);