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