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