git.oblomov.eu Git - linux-2.6/blob - drivers/net/ne2k-pci.c

   1 /* ne2k-pci.c: A NE2000 clone on PCI bus driver for Linux. */
   2 /*
   3         A Linux device driver for PCI NE2000 clones.
   4
   5         Authors and other copyright holders:
   6         1992-2000 by Donald Becker, NE2000 core and various modifications.
   7         1995-1998 by Paul Gortmaker, core modifications and PCI support.
   8         Copyright 1993 assigned to the United States Government as represented
   9         by the Director, National Security Agency.
  10
  11         This software may be used and distributed according to the terms of
  12         the GNU General Public License (GPL), incorporated herein by reference.
  13         Drivers based on or derived from this code fall under the GPL and must
  14         retain the authorship, copyright and license notice.  This file is not
  15         a complete program and may only be used when the entire operating
  16         system is licensed under the GPL.
  17
  18         The author may be reached as becker@scyld.com, or C/O
  19         Scyld Computing Corporation
  20         410 Severn Ave., Suite 210
  21         Annapolis MD 21403
  22
  23         Issues remaining:
  24         People are making PCI ne2000 clones! Oh the horror, the horror...
  25         Limited full-duplex support.
  26 */
  27
  28 #define DRV_NAME        "ne2k-pci"
  29 #define DRV_VERSION     "1.03"
  30 #define DRV_RELDATE     "9/22/2003"
  31
  32
  33 /* The user-configurable values.
  34    These may be modified when a driver module is loaded.*/
  35
  36 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
  37
  38 #define MAX_UNITS 8                             /* More are supported, limit only on options */
  39 /* Used to pass the full-duplex flag, etc. */
  40 static int full_duplex[MAX_UNITS];
  41 static int options[MAX_UNITS];
  42
  43 /* Force a non std. amount of memory.  Units are 256 byte pages. */
  44 /* #define PACKETBUF_MEMSIZE    0x40 */
  45
  46
  47 #include <linux/module.h>
  48 #include <linux/kernel.h>
  49 #include <linux/errno.h>
  50 #include <linux/pci.h>
  51 #include <linux/init.h>
  52 #include <linux/interrupt.h>
  53 #include <linux/ethtool.h>
  54 #include <linux/netdevice.h>
  55 #include <linux/etherdevice.h>
  56
  57 #include <asm/system.h>
  58 #include <asm/io.h>
  59 #include <asm/irq.h>
  60 #include <asm/uaccess.h>
  61
  62 #include "8390.h"
  63
  64 /* These identify the driver base version and may not be removed. */
  65 static char version[] __devinitdata =
  66 KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " D. Becker/P. Gortmaker\n"
  67 KERN_INFO "  http://www.scyld.com/network/ne2k-pci.html\n";
  68
  69 #if defined(__powerpc__)
  70 #define inl_le(addr)  le32_to_cpu(inl(addr))
  71 #define inw_le(addr)  le16_to_cpu(inw(addr))
  72 #endif
  73
  74 #define PFX DRV_NAME ": "
  75
  76 MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
  77 MODULE_DESCRIPTION("PCI NE2000 clone driver");
  78 MODULE_LICENSE("GPL");
  79
  80 module_param(debug, int, 0);
  81 module_param_array(options, int, NULL, 0);
  82 module_param_array(full_duplex, int, NULL, 0);
  83 MODULE_PARM_DESC(debug, "debug level (1-2)");
  84 MODULE_PARM_DESC(options, "Bit 5: full duplex");
  85 MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)");
  86
  87 /* Some defines that people can play with if so inclined. */
  88
  89 /* Use 32 bit data-movement operations instead of 16 bit. */
  90 #define USE_LONGIO
  91
  92 /* Do we implement the read before write bugfix ? */
  93 /* #define NE_RW_BUGFIX */
  94
  95 /* Flags.  We rename an existing ei_status field to store flags! */
  96 /* Thus only the low 8 bits are usable for non-init-time flags. */
  97 #define ne2k_flags reg0
  98 enum {
  99         ONLY_16BIT_IO=8, ONLY_32BIT_IO=4,       /* Chip can do only 16/32-bit xfers. */
 100         FORCE_FDX=0x20,                                         /* User override. */
 101         REALTEK_FDX=0x40, HOLTEK_FDX=0x80,
 102         STOP_PG_0x60=0x100,
 103 };
 104
 105 enum ne2k_pci_chipsets {
 106         CH_RealTek_RTL_8029 = 0,
 107         CH_Winbond_89C940,
 108         CH_Compex_RL2000,
 109         CH_KTI_ET32P2,
 110         CH_NetVin_NV5000SC,
 111         CH_Via_86C926,
 112         CH_SureCom_NE34,
 113         CH_Winbond_W89C940F,
 114         CH_Holtek_HT80232,
 115         CH_Holtek_HT80229,
 116         CH_Winbond_89C940_8c4a,
 117 };
 118
 119
 120 static struct {
 121         char *name;
 122         int flags;
 123 } pci_clone_list[] __devinitdata = {
 124         {"RealTek RTL-8029", REALTEK_FDX},
 125         {"Winbond 89C940", 0},
 126         {"Compex RL2000", 0},
 127         {"KTI ET32P2", 0},
 128         {"NetVin NV5000SC", 0},
 129         {"Via 86C926", ONLY_16BIT_IO},
 130         {"SureCom NE34", 0},
 131         {"Winbond W89C940F", 0},
 132         {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
 133         {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
 134         {"Winbond W89C940(misprogrammed)", 0},
 135         {NULL,}
 136 };
 137
 138
 139 static struct pci_device_id ne2k_pci_tbl[] = {
 140         { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
 141         { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
 142         { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
 143         { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
 144         { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
 145         { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
 146         { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
 147         { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
 148         { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
 149         { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
 150         { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
 151         { 0, }
 152 };
 153 MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
 154
 155
 156 /* ---- No user-serviceable parts below ---- */
 157
 158 #define NE_BASE  (dev->base_addr)
 159 #define NE_CMD          0x00
 160 #define NE_DATAPORT     0x10    /* NatSemi-defined port window offset. */
 161 #define NE_RESET        0x1f    /* Issue a read to reset, a write to clear. */
 162 #define NE_IO_EXTENT    0x20
 163
 164 #define NESM_START_PG   0x40    /* First page of TX buffer */
 165 #define NESM_STOP_PG    0x80    /* Last page +1 of RX ring */
 166
 167
 168 static int ne2k_pci_open(struct net_device *dev);
 169 static int ne2k_pci_close(struct net_device *dev);
 170
 171 static void ne2k_pci_reset_8390(struct net_device *dev);
 172 static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
 173                           int ring_page);
 174 static void ne2k_pci_block_input(struct net_device *dev, int count,
 175                           struct sk_buff *skb, int ring_offset);
 176 static void ne2k_pci_block_output(struct net_device *dev, const int count,
 177                 const unsigned char *buf, const int start_page);
 178 static const struct ethtool_ops ne2k_pci_ethtool_ops;
 179
 180
 181
 182 /* There is no room in the standard 8390 structure for extra info we need,
 183    so we build a meta/outer-wrapper structure.. */
 184 struct ne2k_pci_card {
 185         struct net_device *dev;
 186         struct pci_dev *pci_dev;
 187 };
 188
 189
 190
 191 /*
 192   NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
 193   buffer memory space.  By-the-spec NE2000 clones have 0x57,0x57 in bytes
 194   0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
 195   detected by their SA prefix.
 196
 197   Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
 198   mode results in doubled values, which can be detected and compensated for.
 199
 200   The probe is also responsible for initializing the card and filling
 201   in the 'dev' and 'ei_status' structures.
 202 */
 203
 204
 205 static int __devinit ne2k_pci_init_one (struct pci_dev *pdev,
 206                                      const struct pci_device_id *ent)
 207 {
 208         struct net_device *dev;
 209         int i;
 210         unsigned char SA_prom[32];
 211         int start_page, stop_page;
 212         int irq, reg0, chip_idx = ent->driver_data;
 213         static unsigned int fnd_cnt;
 214         long ioaddr;
 215         int flags = pci_clone_list[chip_idx].flags;
 216
 217 /* when built into the kernel, we only print version if device is found */
 218 #ifndef MODULE
 219         static int printed_version;
 220         if (!printed_version++)
 221                 printk(version);
 222 #endif
 223
 224         fnd_cnt++;
 225
 226         i = pci_enable_device (pdev);
 227         if (i)
 228                 return i;
 229
 230         ioaddr = pci_resource_start (pdev, 0);
 231         irq = pdev->irq;
 232
 233         if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
 234                 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
 235                 return -ENODEV;
 236         }
 237
 238         if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) {
 239                 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
 240                         NE_IO_EXTENT, ioaddr);
 241                 return -EBUSY;
 242         }
 243
 244         reg0 = inb(ioaddr);
 245         if (reg0 == 0xFF)
 246                 goto err_out_free_res;
 247
 248         /* Do a preliminary verification that we have a 8390. */
 249         {
 250                 int regd;
 251                 outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
 252                 regd = inb(ioaddr + 0x0d);
 253                 outb(0xff, ioaddr + 0x0d);
 254                 outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
 255                 inb(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
 256                 if (inb(ioaddr + EN0_COUNTER0) != 0) {
 257                         outb(reg0, ioaddr);
 258                         outb(regd, ioaddr + 0x0d);      /* Restore the old values. */
 259                         goto err_out_free_res;
 260                 }
 261         }
 262
 263         /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
 264         dev = alloc_ei_netdev();
 265         if (!dev) {
 266                 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
 267                 goto err_out_free_res;
 268         }
 269         SET_MODULE_OWNER(dev);
 270         SET_NETDEV_DEV(dev, &pdev->dev);
 271
 272         /* Reset card. Who knows what dain-bramaged state it was left in. */
 273         {
 274                 unsigned long reset_start_time = jiffies;
 275
 276                 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
 277
 278                 /* This looks like a horrible timing loop, but it should never take
 279                    more than a few cycles.
 280                 */
 281                 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
 282                         /* Limit wait: '2' avoids jiffy roll-over. */
 283                         if (jiffies - reset_start_time > 2) {
 284                                 dev_err(&pdev->dev,
 285                                         "Card failure (no reset ack).\n");
 286                                 goto err_out_free_netdev;
 287                         }
 288
 289                 outb(0xff, ioaddr + EN0_ISR);           /* Ack all intr. */
 290         }
 291
 292         /* Read the 16 bytes of station address PROM.
 293            We must first initialize registers, similar to NS8390_init(eifdev, 0).
 294            We can't reliably read the SAPROM address without this.
 295            (I learned the hard way!). */
 296         {
 297                 struct {unsigned char value, offset; } program_seq[] = {
 298                         {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 299                         {0x49,  EN0_DCFG},      /* Set word-wide access. */
 300                         {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 301                         {0x00,  EN0_RCNTHI},
 302                         {0x00,  EN0_IMR},       /* Mask completion irq. */
 303                         {0xFF,  EN0_ISR},
 304                         {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
 305                         {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 306                         {32,    EN0_RCNTLO},
 307                         {0x00,  EN0_RCNTHI},
 308                         {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
 309                         {0x00,  EN0_RSARHI},
 310                         {E8390_RREAD+E8390_START, E8390_CMD},
 311                 };
 312                 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
 313                         outb(program_seq[i].value, ioaddr + program_seq[i].offset);
 314
 315         }
 316
 317         /* Note: all PCI cards have at least 16 bit access, so we don't have
 318            to check for 8 bit cards.  Most cards permit 32 bit access. */
 319         if (flags & ONLY_32BIT_IO) {
 320                 for (i = 0; i < 4 ; i++)
 321                         ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
 322         } else
 323                 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i++)
 324                         SA_prom[i] = inb(ioaddr + NE_DATAPORT);
 325
 326         /* We always set the 8390 registers for word mode. */
 327         outb(0x49, ioaddr + EN0_DCFG);
 328         start_page = NESM_START_PG;
 329
 330         stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
 331
 332         /* Set up the rest of the parameters. */
 333         dev->irq = irq;
 334         dev->base_addr = ioaddr;
 335         pci_set_drvdata(pdev, dev);
 336
 337         ei_status.name = pci_clone_list[chip_idx].name;
 338         ei_status.tx_start_page = start_page;
 339         ei_status.stop_page = stop_page;
 340         ei_status.word16 = 1;
 341         ei_status.ne2k_flags = flags;
 342         if (fnd_cnt < MAX_UNITS) {
 343                 if (full_duplex[fnd_cnt] > 0  ||  (options[fnd_cnt] & FORCE_FDX))
 344                         ei_status.ne2k_flags |= FORCE_FDX;
 345         }
 346
 347         ei_status.rx_start_page = start_page + TX_PAGES;
 348 #ifdef PACKETBUF_MEMSIZE
 349         /* Allow the packet buffer size to be overridden by know-it-alls. */
 350         ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
 351 #endif
 352
 353         ei_status.reset_8390 = &ne2k_pci_reset_8390;
 354         ei_status.block_input = &ne2k_pci_block_input;
 355         ei_status.block_output = &ne2k_pci_block_output;
 356         ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
 357         ei_status.priv = (unsigned long) pdev;
 358         dev->open = &ne2k_pci_open;
 359         dev->stop = &ne2k_pci_close;
 360         dev->ethtool_ops = &ne2k_pci_ethtool_ops;
 361 #ifdef CONFIG_NET_POLL_CONTROLLER
 362         dev->poll_controller = ei_poll;
 363 #endif
 364         NS8390_init(dev, 0);
 365
 366         i = register_netdev(dev);
 367         if (i)
 368                 goto err_out_free_netdev;
 369
 370         printk("%s: %s found at %#lx, IRQ %d, ",
 371                    dev->name, pci_clone_list[chip_idx].name, ioaddr, dev->irq);
 372         for(i = 0; i < 6; i++) {
 373                 printk("%2.2X%s", SA_prom[i], i == 5 ? ".\n": ":");
 374                 dev->dev_addr[i] = SA_prom[i];
 375         }
 376         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 377
 378         return 0;
 379
 380 err_out_free_netdev:
 381         free_netdev (dev);
 382 err_out_free_res:
 383         release_region (ioaddr, NE_IO_EXTENT);
 384         pci_set_drvdata (pdev, NULL);
 385         return -ENODEV;
 386
 387 }
 388
 389 /*
 390  * Magic incantation sequence for full duplex on the supported cards.
 391  */
 392 static inline int set_realtek_fdx(struct net_device *dev)
 393 {
 394         long ioaddr = dev->base_addr;
 395
 396         outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
 397         outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
 398         outb(0x40, ioaddr + 0x06); /* Enable full duplex */
 399         outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
 400         outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
 401         return 0;
 402 }
 403
 404 static inline int set_holtek_fdx(struct net_device *dev)
 405 {
 406         long ioaddr = dev->base_addr;
 407
 408         outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
 409         return 0;
 410 }
 411
 412 static int ne2k_pci_set_fdx(struct net_device *dev)
 413 {
 414         if (ei_status.ne2k_flags & REALTEK_FDX)
 415                 return set_realtek_fdx(dev);
 416         else if (ei_status.ne2k_flags & HOLTEK_FDX)
 417                 return set_holtek_fdx(dev);
 418
 419         return -EOPNOTSUPP;
 420 }
 421
 422 static int ne2k_pci_open(struct net_device *dev)
 423 {
 424         int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED, dev->name, dev);
 425         if (ret)
 426                 return ret;
 427
 428         if (ei_status.ne2k_flags & FORCE_FDX)
 429                 ne2k_pci_set_fdx(dev);
 430
 431         ei_open(dev);
 432         return 0;
 433 }
 434
 435 static int ne2k_pci_close(struct net_device *dev)
 436 {
 437         ei_close(dev);
 438         free_irq(dev->irq, dev);
 439         return 0;
 440 }
 441
 442 /* Hard reset the card.  This used to pause for the same period that a
 443    8390 reset command required, but that shouldn't be necessary. */
 444 static void ne2k_pci_reset_8390(struct net_device *dev)
 445 {
 446         unsigned long reset_start_time = jiffies;
 447
 448         if (debug > 1) printk("%s: Resetting the 8390 t=%ld...",
 449                                                   dev->name, jiffies);
 450
 451         outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
 452
 453         ei_status.txing = 0;
 454         ei_status.dmaing = 0;
 455
 456         /* This check _should_not_ be necessary, omit eventually. */
 457         while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
 458                 if (jiffies - reset_start_time > 2) {
 459                         printk("%s: ne2k_pci_reset_8390() did not complete.\n", dev->name);
 460                         break;
 461                 }
 462         outb(ENISR_RESET, NE_BASE + EN0_ISR);   /* Ack intr. */
 463 }
 464
 465 /* Grab the 8390 specific header. Similar to the block_input routine, but
 466    we don't need to be concerned with ring wrap as the header will be at
 467    the start of a page, so we optimize accordingly. */
 468
 469 static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 470 {
 471
 472         long nic_base = dev->base_addr;
 473
 474         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 475         if (ei_status.dmaing) {
 476                 printk("%s: DMAing conflict in ne2k_pci_get_8390_hdr "
 477                            "[DMAstat:%d][irqlock:%d].\n",
 478                            dev->name, ei_status.dmaing, ei_status.irqlock);
 479                 return;
 480         }
 481
 482         ei_status.dmaing |= 0x01;
 483         outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 484         outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
 485         outb(0, nic_base + EN0_RCNTHI);
 486         outb(0, nic_base + EN0_RSARLO);         /* On page boundary */
 487         outb(ring_page, nic_base + EN0_RSARHI);
 488         outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 489
 490         if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 491                 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
 492         } else {
 493                 *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
 494                 le16_to_cpus(&hdr->count);
 495         }
 496
 497         outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 498         ei_status.dmaing &= ~0x01;
 499 }
 500
 501 /* Block input and output, similar to the Crynwr packet driver.  If you
 502    are porting to a new ethercard, look at the packet driver source for hints.
 503    The NEx000 doesn't share the on-board packet memory -- you have to put
 504    the packet out through the "remote DMA" dataport using outb. */
 505
 506 static void ne2k_pci_block_input(struct net_device *dev, int count,
 507                                  struct sk_buff *skb, int ring_offset)
 508 {
 509         long nic_base = dev->base_addr;
 510         char *buf = skb->data;
 511
 512         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 513         if (ei_status.dmaing) {
 514                 printk("%s: DMAing conflict in ne2k_pci_block_input "
 515                            "[DMAstat:%d][irqlock:%d].\n",
 516                            dev->name, ei_status.dmaing, ei_status.irqlock);
 517                 return;
 518         }
 519         ei_status.dmaing |= 0x01;
 520         if (ei_status.ne2k_flags & ONLY_32BIT_IO)
 521                 count = (count + 3) & 0xFFFC;
 522         outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 523         outb(count & 0xff, nic_base + EN0_RCNTLO);
 524         outb(count >> 8, nic_base + EN0_RCNTHI);
 525         outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
 526         outb(ring_offset >> 8, nic_base + EN0_RSARHI);
 527         outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 528
 529         if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 530                 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
 531                 if (count & 0x01) {
 532                         buf[count-1] = inb(NE_BASE + NE_DATAPORT);
 533                 }
 534         } else {
 535                 insl(NE_BASE + NE_DATAPORT, buf, count>>2);
 536                 if (count & 3) {
 537                         buf += count & ~3;
 538                         if (count & 2) {
 539                                 u16 *b = (u16 *)buf;
 540
 541                                 *b++ = le16_to_cpu(inw(NE_BASE + NE_DATAPORT));
 542                                 buf = (char *)b;
 543                         }
 544                         if (count & 1)
 545                                 *buf = inb(NE_BASE + NE_DATAPORT);
 546                 }
 547         }
 548
 549         outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 550         ei_status.dmaing &= ~0x01;
 551 }
 552
 553 static void ne2k_pci_block_output(struct net_device *dev, int count,
 554                                   const unsigned char *buf, const int start_page)
 555 {
 556         long nic_base = NE_BASE;
 557         unsigned long dma_start;
 558
 559         /* On little-endian it's always safe to round the count up for
 560            word writes. */
 561         if (ei_status.ne2k_flags & ONLY_32BIT_IO)
 562                 count = (count + 3) & 0xFFFC;
 563         else
 564                 if (count & 0x01)
 565                         count++;
 566
 567         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 568         if (ei_status.dmaing) {
 569                 printk("%s: DMAing conflict in ne2k_pci_block_output."
 570                            "[DMAstat:%d][irqlock:%d]\n",
 571                            dev->name, ei_status.dmaing, ei_status.irqlock);
 572                 return;
 573         }
 574         ei_status.dmaing |= 0x01;
 575         /* We should already be in page 0, but to be safe... */
 576         outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
 577
 578 #ifdef NE8390_RW_BUGFIX
 579         /* Handle the read-before-write bug the same way as the
 580            Crynwr packet driver -- the NatSemi method doesn't work.
 581            Actually this doesn't always work either, but if you have
 582            problems with your NEx000 this is better than nothing! */
 583         outb(0x42, nic_base + EN0_RCNTLO);
 584         outb(0x00, nic_base + EN0_RCNTHI);
 585         outb(0x42, nic_base + EN0_RSARLO);
 586         outb(0x00, nic_base + EN0_RSARHI);
 587         outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 588 #endif
 589         outb(ENISR_RDC, nic_base + EN0_ISR);
 590
 591    /* Now the normal output. */
 592         outb(count & 0xff, nic_base + EN0_RCNTLO);
 593         outb(count >> 8,   nic_base + EN0_RCNTHI);
 594         outb(0x00, nic_base + EN0_RSARLO);
 595         outb(start_page, nic_base + EN0_RSARHI);
 596         outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
 597         if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 598                 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
 599         } else {
 600                 outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
 601                 if (count & 3) {
 602                         buf += count & ~3;
 603                         if (count & 2) {
 604                                 u16 *b = (u16 *)buf;
 605
 606                                 outw(cpu_to_le16(*b++), NE_BASE + NE_DATAPORT);
 607                                 buf = (char *)b;
 608                         }
 609                 }
 610         }
 611
 612         dma_start = jiffies;
 613
 614         while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
 615                 if (jiffies - dma_start > 2) {                  /* Avoid clock roll-over. */
 616                         printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
 617                         ne2k_pci_reset_8390(dev);
 618                         NS8390_init(dev,1);
 619                         break;
 620                 }
 621
 622         outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 623         ei_status.dmaing &= ~0x01;
 624         return;
 625 }
 626
 627 static void ne2k_pci_get_drvinfo(struct net_device *dev,
 628                                  struct ethtool_drvinfo *info)
 629 {
 630         struct ei_device *ei = dev->priv;
 631         struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
 632
 633         strcpy(info->driver, DRV_NAME);
 634         strcpy(info->version, DRV_VERSION);
 635         strcpy(info->bus_info, pci_name(pci_dev));
 636 }
 637
 638 static const struct ethtool_ops ne2k_pci_ethtool_ops = {
 639         .get_drvinfo            = ne2k_pci_get_drvinfo,
 640         .get_tx_csum            = ethtool_op_get_tx_csum,
 641         .get_sg                 = ethtool_op_get_sg,
 642         .get_perm_addr          = ethtool_op_get_perm_addr,
 643 };
 644
 645 static void __devexit ne2k_pci_remove_one (struct pci_dev *pdev)
 646 {
 647         struct net_device *dev = pci_get_drvdata(pdev);
 648
 649         BUG_ON(!dev);
 650         unregister_netdev(dev);
 651         release_region(dev->base_addr, NE_IO_EXTENT);
 652         free_netdev(dev);
 653         pci_disable_device(pdev);
 654         pci_set_drvdata(pdev, NULL);
 655 }
 656
 657 #ifdef CONFIG_PM
 658 static int ne2k_pci_suspend (struct pci_dev *pdev, pm_message_t state)
 659 {
 660         struct net_device *dev = pci_get_drvdata (pdev);
 661
 662         netif_device_detach(dev);
 663         pci_save_state(pdev);
 664         pci_disable_device(pdev);
 665         pci_set_power_state(pdev, pci_choose_state(pdev, state));
 666
 667         return 0;
 668 }
 669
 670 static int ne2k_pci_resume (struct pci_dev *pdev)
 671 {
 672         struct net_device *dev = pci_get_drvdata (pdev);
 673
 674         pci_set_power_state(pdev, 0);
 675         pci_restore_state(pdev);
 676         pci_enable_device(pdev);
 677         NS8390_init(dev, 1);
 678         netif_device_attach(dev);
 679
 680         return 0;
 681 }
 682
 683 #endif /* CONFIG_PM */
 684
 685
 686 static struct pci_driver ne2k_driver = {
 687         .name           = DRV_NAME,
 688         .probe          = ne2k_pci_init_one,
 689         .remove         = __devexit_p(ne2k_pci_remove_one),
 690         .id_table       = ne2k_pci_tbl,
 691 #ifdef CONFIG_PM
 692         .suspend        = ne2k_pci_suspend,
 693         .resume         = ne2k_pci_resume,
 694 #endif /* CONFIG_PM */
 695
 696 };
 697
 698
 699 static int __init ne2k_pci_init(void)
 700 {
 701 /* when a module, this is printed whether or not devices are found in probe */
 702 #ifdef MODULE
 703         printk(version);
 704 #endif
 705         return pci_register_driver(&ne2k_driver);
 706 }
 707
 708
 709 static void __exit ne2k_pci_cleanup(void)
 710 {
 711         pci_unregister_driver (&ne2k_driver);
 712 }
 713
 714 module_init(ne2k_pci_init);
 715 module_exit(ne2k_pci_cleanup);