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 = dev_alloc_skb(sizeof(*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         skb->dev = dev;
 453         skb->protocol = htons(ETH_P_CAN);
 454         cf = (struct can_frame *)skb_put(skb, sizeof(*cf));
 455         memset(cf, 0, sizeof(*cf));
 456
 457         cf->can_id = CAN_ERR_FLAG | idflags;
 458         cf->can_dlc = CAN_ERR_DLC;
 459         cf->data[1] = d1;
 460
 461         netif_rx(skb);
 462
 463 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 464         dev->last_rx = jiffies;
 465 #endif
 466         stats->rx_packets++;
 467         stats->rx_bytes += cf->can_dlc;
 468
 469         return 0;
 470 }
 471
 472 static void esd331_irq_rx(struct net_device *dev, struct esd331_can_msg *msg,
 473                                 int eff)
 474 {
 475 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 476         struct net_device_stats *stats = can_get_stats(dev);
 477 #else
 478         struct net_device_stats *stats = &dev->stats;
 479 #endif
 480         struct can_frame *cfrm;
 481         struct sk_buff *skb;
 482         int i;
 483
 484         skb = netdev_alloc_skb(dev, sizeof(*cfrm));
 485         if (unlikely(skb == NULL)) {
 486                 stats->rx_dropped++;
 487                 return;
 488         }
 489         skb->protocol = htons(ETH_P_CAN);
 490
 491         cfrm = (struct can_frame *)skb_put(skb, sizeof(*cfrm));
 492         memset(cfrm, 0, sizeof(*cfrm));
 493
 494         if (eff) {
 495                 cfrm->can_id = (msg->id << 16);
 496                 cfrm->can_id |= (msg->x2);
 497         } else {
 498                 cfrm->can_id = msg->id;
 499         }
 500         if (msg->len & ESD331_RTR_FLAG)
 501                 cfrm->can_id |= CAN_RTR_FLAG;
 502
 503         if (eff)
 504                 cfrm->can_id |= CAN_EFF_FLAG;
 505
 506         cfrm->can_dlc = msg->len & ESD331_DLC_MASK;
 507
 508         if (cfrm->can_dlc > 8)
 509                 cfrm->can_dlc = 8;
 510
 511         for (i = 0; i < cfrm->can_dlc; ++i)
 512                 cfrm->data[i] = msg->data[i];
 513
 514         netif_rx(skb);
 515
 516 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 517         dev->last_rx = jiffies;
 518 #endif
 519         stats->rx_packets++;
 520         stats->rx_bytes += cfrm->can_dlc;
 521 }
 522
 523 static void esd331_handle_errmsg(struct net_device *dev,
 524                                         struct esd331_can_msg *msg)
 525 {
 526         struct esd331_priv *priv = netdev_priv(dev);
 527
 528         if (msg->id & ESD331_EVENT_MASK)
 529                 return;
 530
 531         switch (msg->data[1]) {
 532         case ESD331_ERR_OK:
 533                 if (priv->can.state != CAN_STATE_STOPPED)
 534                         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 535                 break;
 536
 537         case ESD331_ERR_WARN:
 538                 if ((priv->can.state != CAN_STATE_ERROR_WARNING)
 539                                 && (priv->can.state != CAN_STATE_STOPPED)) {
 540                         priv->can.can_stats.error_warning++;
 541                         priv->can.state = CAN_STATE_ERROR_WARNING;
 542
 543                         /* might be RX warning, too... */
 544                         esd331_create_err_frame(dev, CAN_ERR_CRTL,
 545                                                 CAN_ERR_CRTL_TX_WARNING);
 546                 }
 547                 break;
 548
 549         case ESD331_ERR_BUSOFF1:
 550         case ESD331_ERR_BUSOFF2:
 551                 if ((priv->can.state != CAN_STATE_BUS_OFF)
 552                                 && (priv->can.state != CAN_STATE_STOPPED)) {
 553                         priv->can.state = CAN_STATE_BUS_OFF;
 554                         esd331_create_err_frame(dev, CAN_ERR_BUSOFF, 0);
 555                         can_bus_off(dev);
 556                 }
 557                 break;
 558
 559         default:
 560                 break;
 561         }
 562
 563 }
 564
 565 static void esd331_handle_messages(struct esd331_pci *board)
 566 {
 567         struct net_device *dev;
 568         struct esd331_priv *priv;
 569         struct net_device_stats *stats;
 570         struct esd331_can_msg msg;
 571         int msg_count = ESD331_MAX_INTERRUPT_WORK;
 572
 573         while ((esd331_read(&msg, board) == 0) && (msg_count--)) {
 574                 if (unlikely((msg.net >= ESD331_MAX_CAN)
 575                                 || (board->dev[msg.net] == NULL)))
 576                         continue;
 577
 578                 dev = board->dev[msg.net];
 579                 priv = netdev_priv(dev);
 580                 if (priv->can.state == CAN_STATE_STOPPED)
 581                         continue;
 582
 583 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 584                 stats = can_get_stats(dev);
 585 #else
 586                 stats = &dev->stats;
 587 #endif
 588                 switch (msg.cmmd) {
 589
 590                 case ESD331_I20_BCAN:
 591                 case ESD331_I20_EX_BCAN:
 592                         esd331_irq_rx(dev, &msg,
 593                                         (msg.cmmd == ESD331_I20_EX_BCAN));
 594                         break;
 595
 596                 case ESD331_I20_TXDONE:
 597                 case ESD331_I20_EX_TXDONE:
 598                         stats->tx_packets++;
 599                         can_get_echo_skb(dev, 0);
 600                         netif_wake_queue(dev);
 601                         break;
 602
 603                 case ESD331_I20_TXTOUT:
 604                 case ESD331_I20_EX_TXTOUT:
 605                         stats->tx_errors++;
 606                         stats->tx_dropped++;
 607                         can_free_echo_skb(dev, 0);
 608                         netif_wake_queue(dev);
 609                         break;
 610
 611                 case ESD331_I20_ERROR:
 612                         esd331_handle_errmsg(dev, &msg);
 613                         break;
 614
 615                 default:
 616                         break;
 617                 }
 618         }
 619 }
 620
 621 static int esd331_all_nets_stopped(struct esd331_pci *board)
 622 {
 623         int i;
 624
 625         for (i = 0; i < ESD331_MAX_CAN; i++) {
 626                 if (board->dev[i] == NULL) {
 627                         break;
 628                 } else {
 629                         struct esd331_priv *priv = netdev_priv(board->dev[i]);
 630
 631                         if (priv->can.state != CAN_STATE_STOPPED)
 632                                 return 0;
 633                 }
 634         }
 635
 636         return 1;
 637 }
 638
 639 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 640 irqreturn_t esd331_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 641 #else
 642 irqreturn_t esd331_interrupt(int irq, void *dev_id)
 643 #endif
 644 {
 645         struct esd331_pci *board = (struct esd331_pci *)dev_id;
 646         void __iomem *ics = board->conf_addr + ESD331_CONF_OFFS_ICS;
 647
 648         if (!(readl(ics) & ESD331_IRQ_FLAG))
 649                 return IRQ_NONE;
 650
 651         writew(0xffff, board->base_addr2 + ESD331_OFFS_IRQ_ACK);
 652         esd331_handle_messages(board);
 653
 654         return IRQ_HANDLED;
 655 }
 656
 657 /* also enables interrupt when no other net on card is openened yet */
 658 static int esd331_open(struct net_device *dev)
 659 {
 660         struct esd331_priv *priv = netdev_priv(dev);
 661         int err;
 662
 663         err = open_candev(dev);
 664         if (err)
 665                 return err;
 666
 667 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 668         memset(&priv->can.net_stats, 0, sizeof(priv->can.net_stats));
 669 #endif
 670
 671         if (esd331_all_nets_stopped(priv->board))
 672                 esd331_enable_irq(priv->board->conf_addr);
 673
 674         priv->can.state = CAN_STATE_ERROR_ACTIVE;
 675         netif_start_queue(dev);
 676
 677         return 0;
 678 }
 679
 680 /* also disables interrupt when all other nets on card are closed already*/
 681 static int esd331_close(struct net_device *dev)
 682 {
 683         struct esd331_priv *priv = netdev_priv(dev);
 684
 685         priv->can.state = CAN_STATE_STOPPED;
 686         netif_stop_queue(dev);
 687         close_candev(dev);
 688
 689         if (esd331_all_nets_stopped(priv->board))
 690                 esd331_disable_irq(priv->board->conf_addr);
 691
 692         return 0;
 693 }
 694
 695 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 696 static int esd331_start_xmit(struct sk_buff *skb, struct net_device *dev)
 697 #else
 698 static netdev_tx_t esd331_start_xmit(struct sk_buff *skb,
 699                                         struct net_device *dev)
 700 #endif
 701 {
 702         struct esd331_priv *priv = netdev_priv(dev);
 703 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 704         struct net_device_stats *stats = can_get_stats(dev);
 705 #else
 706         struct net_device_stats *stats = &dev->stats;
 707 #endif
 708         struct can_frame *cf = (struct can_frame *)skb->data;
 709         int err;
 710
 711         can_put_echo_skb(skb, dev, 0);
 712
 713         if ((cf->can_id & CAN_EFF_FLAG) && (priv->board->eff_supp == 0)) {
 714                 stats->tx_errors++;
 715                 stats->tx_dropped++;
 716                 can_free_echo_skb(dev, 0);
 717                 err = -EOPNOTSUPP;
 718                 goto out;
 719         }
 720
 721         err = esd331_send(priv->board, priv->boards_net,
 722                                 cf->can_id & CAN_EFF_MASK,
 723                                 cf->can_id & CAN_EFF_FLAG,
 724                                 cf->can_id & CAN_RTR_FLAG,
 725                                 cf->can_dlc, cf->data);
 726         if (err) {
 727                 stats->tx_fifo_errors++;
 728                 stats->tx_errors++;
 729                 stats->tx_dropped++;
 730                 can_free_echo_skb(dev, 0);
 731                 goto out;
 732         }
 733
 734         netif_stop_queue(dev);
 735         stats->tx_bytes += cf->can_dlc;
 736         dev->trans_start = jiffies;
 737 out:
 738         return err;
 739 }
 740
 741 static int esd331_set_bittiming(struct net_device *dev)
 742 {
 743         struct esd331_priv *priv = netdev_priv(dev);
 744         int i;
 745
 746         for (i = 0; i < ARRAY_SIZE(esd331_baud_table); i++) {
 747                 if (priv->can.bittiming.bitrate == esd331_baud_table[i].rate) {
 748                         return esd331_write_baud(priv->boards_net,
 749                                 esd331_baud_table[i].index, priv->board);
 750                 }
 751         }
 752
 753         return -EINVAL;
 754 }
 755
 756 static int esd331_set_mode(struct net_device *dev, enum can_mode mode)
 757 {
 758         struct esd331_priv *priv = netdev_priv(dev);
 759
 760         switch (mode) {
 761         case CAN_MODE_START:
 762                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
 763                 if (netif_queue_stopped(dev))
 764                         netif_wake_queue(dev);
 765
 766                 break;
 767
 768         default:
 769                 return -EOPNOTSUPP;
 770         }
 771
 772         return 0;
 773 }
 774
 775 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 776 static const struct net_device_ops esd331_netdev_ops = {
 777         .ndo_open = esd331_open,
 778         .ndo_stop = esd331_close,
 779         .ndo_start_xmit = esd331_start_xmit,
 780 };
 781 #endif
 782
 783 static struct net_device *__devinit esd331_pci_add_chan(struct pci_dev *pdev,
 784                 struct esd331_pci *board, u8 boards_net)
 785 {
 786         struct net_device *dev;
 787         struct esd331_priv *priv;
 788         int err;
 789
 790         dev = alloc_candev(sizeof(*priv), ESD331_ECHO_SKB_MAX);
 791         if (dev == NULL)
 792                 return ERR_PTR(-ENOMEM);
 793
 794         priv = netdev_priv(dev);
 795         priv->boards_net = boards_net;
 796         priv->board = board;
 797
 798         SET_NETDEV_DEV(dev, &pdev->dev);
 799
 800 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 801         dev->netdev_ops = &esd331_netdev_ops;
 802 #else
 803         dev->open = esd331_open;
 804         dev->stop = esd331_close;
 805         dev->hard_start_xmit = esd331_start_xmit;
 806 #endif
 807
 808         dev->irq = pdev->irq;
 809         /* Set and enable PCI interrupts */
 810         dev->flags |= IFF_ECHO;
 811
 812         priv->can.do_set_bittiming = esd331_set_bittiming;
 813         priv->can.do_set_mode = esd331_set_mode;
 814
 815         err = register_candev(dev);
 816         if (err) {
 817                 dev_err(&pdev->dev, "registering candev failed\n");
 818                 free_netdev(dev);
 819                 return ERR_PTR(err);
 820         }
 821
 822         dev_info(&pdev->dev, "device %s registered\n", dev->name);
 823
 824         return dev;
 825 }
 826
 827 static int __devinit esd331_pci_init_one(struct pci_dev *pdev,
 828                 const struct pci_device_id *ent)
 829 {
 830         struct esd331_pci *board;
 831         int err;
 832         int i;
 833         int read_features = 0;
 834
 835         dev_info(&pdev->dev,
 836                         "Initializing device %04x:%04x %04x:%04x\n",
 837                         pdev->vendor, pdev->device,
 838                         pdev->subsystem_vendor, pdev->subsystem_device);
 839
 840         board = kzalloc(sizeof(*board), GFP_KERNEL);
 841         if (board == NULL)
 842                 return -ENOMEM;
 843
 844         err = pci_enable_device(pdev);
 845         if (err)
 846                 goto failure;
 847
 848         err = pci_request_regions(pdev, DRV_NAME);
 849         if (err)
 850                 goto failure;
 851
 852         board->conf_addr = pci_iomap(pdev, 0, 0);
 853         if (board->conf_addr == NULL) {
 854                 err = -ENODEV;
 855                 goto failure_release_pci;
 856         }
 857         board->base_addr1 = pci_iomap(pdev, 2, 0);
 858         if (board->base_addr1 == NULL) {
 859                 err = -ENODEV;
 860                 goto failure_iounmap_conf;
 861         }
 862         board->base_addr2 = pci_iomap(pdev, 3, 0);
 863         if (board->base_addr2 == NULL) {
 864                 err = -ENODEV;
 865                 goto failure_iounmap_base1;
 866         }
 867
 868         spin_lock_init(&board->irq_lock);
 869
 870 retry_features:
 871         board->dpr = esd331_init_pointer(board->base_addr1);
 872         err = esd331_read_features(board);
 873         if (err) {
 874                 /* esd331_read_features() works only after board reset */
 875                 /* So if failed: reset board and retry: */
 876                 if (!read_features) {
 877                         read_features++;
 878                         esd331_reset(board->conf_addr, 1);
 879                         goto retry_features;
 880                 }
 881
 882                 goto failure_iounmap_base2;
 883         }
 884
 885         for (i = 0; i < board->net_count; ++i) {
 886                 board->dev[i] = esd331_pci_add_chan(pdev, board, i);
 887                 if (IS_ERR(board->dev[i])) {
 888                         err = (int)board->dev[i];
 889                         goto failure_iounmap_base2;
 890                 }
 891                 if (esd331_write_allid(i, board)) {
 892                         dev_err(&pdev->dev, "device %s failed to enable all "
 893                                                 "IDs\n", board->dev[i]->name);
 894                 }
 895         }
 896
 897         if (esd331_write_fast(board))
 898                 dev_err(&pdev->dev, "failed to enable fast mode\n");
 899
 900 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 901         err = request_irq(pdev->irq, &esd331_interrupt, SA_SHIRQ, "pci331",
 902                         (void *)board);
 903 #else
 904         err = request_irq(pdev->irq, &esd331_interrupt, IRQF_SHARED, "pci331",
 905                         (void *)board);
 906 #endif
 907         if (err) {
 908                 err = -EAGAIN;
 909                 goto failure_iounmap_base2;
 910         }
 911         pci_set_drvdata(pdev, board);
 912         return 0;
 913
 914 failure_iounmap_base2:
 915         pci_iounmap(pdev, board->base_addr2);
 916
 917 failure_iounmap_base1:
 918         pci_iounmap(pdev, board->base_addr1);
 919
 920 failure_iounmap_conf:
 921         pci_iounmap(pdev, board->conf_addr);
 922
 923 failure_release_pci:
 924         pci_release_regions(pdev);
 925
 926 failure:
 927         kfree(board);
 928
 929         return err;
 930 }
 931
 932 static void __devexit esd331_pci_remove_one(struct pci_dev *pdev)
 933 {
 934         struct esd331_pci *board = pci_get_drvdata(pdev);
 935         int i;
 936
 937         esd331_disable_irq(board->conf_addr);
 938         free_irq(pdev->irq, (void *)board);
 939
 940         for (i = 0; i < ESD331_MAX_CAN; i++) {
 941                 if (board->dev[i] == NULL)
 942                         break;
 943
 944                 unregister_candev(board->dev[i]);
 945                 free_netdev(board->dev[i]);
 946         }
 947
 948         esd331_reset(board->conf_addr, 0); /* 0 = No wait for restart here */
 949         /* If module is reloaded too early, it will try a reset with waiting */
 950
 951         pci_iounmap(pdev, board->base_addr2);
 952         pci_iounmap(pdev, board->base_addr1);
 953         pci_iounmap(pdev, board->conf_addr);
 954         pci_release_regions(pdev);
 955
 956         pci_disable_device(pdev);
 957         pci_set_drvdata(pdev, NULL);
 958
 959         kfree(board);
 960 }
 961
 962 static struct pci_driver esd331_pci_driver = {
 963         .name = DRV_NAME,
 964         .id_table = esd331_pci_tbl,
 965         .probe = esd331_pci_init_one,
 966         .remove = __devexit_p(esd331_pci_remove_one), };
 967
 968 static int __init esd331_pci_init(void)
 969 {
 970         printk(KERN_INFO "%s CAN netdevice driver\n", DRV_NAME);
 971         return pci_register_driver(&esd331_pci_driver);
 972 }
 973
 974 static void __exit esd331_pci_exit(void)
 975 {
 976         pci_unregister_driver(&esd331_pci_driver);
 977         printk(KERN_INFO "%s driver removed\n", DRV_NAME);
 978 }
 979
 980 module_init(esd331_pci_init);
 981 module_exit(esd331_pci_exit);