linux/drivers/net/ne2k-pci.c
<<
>>
Prefs
   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
  36static 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. */
  40static int full_duplex[MAX_UNITS];
  41static 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. */
  65static const char version[] __devinitconst =
  66        KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE
  67        " D. Becker/P. Gortmaker\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
  76MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
  77MODULE_DESCRIPTION("PCI NE2000 clone driver");
  78MODULE_LICENSE("GPL");
  79
  80module_param(debug, int, 0);
  81module_param_array(options, int, NULL, 0);
  82module_param_array(full_duplex, int, NULL, 0);
  83MODULE_PARM_DESC(debug, "debug level (1-2)");
  84MODULE_PARM_DESC(options, "Bit 5: full duplex");
  85MODULE_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
  98enum {
  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
 105enum 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
 120static 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
 139static DEFINE_PCI_DEVICE_TABLE(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};
 153MODULE_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
 168static int ne2k_pci_open(struct net_device *dev);
 169static int ne2k_pci_close(struct net_device *dev);
 170
 171static void ne2k_pci_reset_8390(struct net_device *dev);
 172static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
 173                          int ring_page);
 174static void ne2k_pci_block_input(struct net_device *dev, int count,
 175                          struct sk_buff *skb, int ring_offset);
 176static void ne2k_pci_block_output(struct net_device *dev, const int count,
 177                const unsigned char *buf, const int start_page);
 178static 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.. */
 184struct 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
 204static const struct net_device_ops ne2k_netdev_ops = {
 205        .ndo_open               = ne2k_pci_open,
 206        .ndo_stop               = ne2k_pci_close,
 207        .ndo_start_xmit         = ei_start_xmit,
 208        .ndo_tx_timeout         = ei_tx_timeout,
 209        .ndo_get_stats          = ei_get_stats,
 210        .ndo_set_multicast_list = ei_set_multicast_list,
 211        .ndo_validate_addr      = eth_validate_addr,
 212        .ndo_set_mac_address    = eth_mac_addr,
 213        .ndo_change_mtu         = eth_change_mtu,
 214#ifdef CONFIG_NET_POLL_CONTROLLER
 215        .ndo_poll_controller = ei_poll,
 216#endif
 217};
 218
 219static int __devinit ne2k_pci_init_one (struct pci_dev *pdev,
 220                                     const struct pci_device_id *ent)
 221{
 222        struct net_device *dev;
 223        int i;
 224        unsigned char SA_prom[32];
 225        int start_page, stop_page;
 226        int irq, reg0, chip_idx = ent->driver_data;
 227        static unsigned int fnd_cnt;
 228        long ioaddr;
 229        int flags = pci_clone_list[chip_idx].flags;
 230
 231/* when built into the kernel, we only print version if device is found */
 232#ifndef MODULE
 233        static int printed_version;
 234        if (!printed_version++)
 235                printk(version);
 236#endif
 237
 238        fnd_cnt++;
 239
 240        i = pci_enable_device (pdev);
 241        if (i)
 242                return i;
 243
 244        ioaddr = pci_resource_start (pdev, 0);
 245        irq = pdev->irq;
 246
 247        if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
 248                dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
 249                return -ENODEV;
 250        }
 251
 252        if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) {
 253                dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
 254                        NE_IO_EXTENT, ioaddr);
 255                return -EBUSY;
 256        }
 257
 258        reg0 = inb(ioaddr);
 259        if (reg0 == 0xFF)
 260                goto err_out_free_res;
 261
 262        /* Do a preliminary verification that we have a 8390. */
 263        {
 264                int regd;
 265                outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
 266                regd = inb(ioaddr + 0x0d);
 267                outb(0xff, ioaddr + 0x0d);
 268                outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
 269                inb(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
 270                if (inb(ioaddr + EN0_COUNTER0) != 0) {
 271                        outb(reg0, ioaddr);
 272                        outb(regd, ioaddr + 0x0d);      /* Restore the old values. */
 273                        goto err_out_free_res;
 274                }
 275        }
 276
 277        /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
 278        dev = alloc_ei_netdev();
 279        if (!dev) {
 280                dev_err(&pdev->dev, "cannot allocate ethernet device\n");
 281                goto err_out_free_res;
 282        }
 283        dev->netdev_ops = &ne2k_netdev_ops;
 284
 285        SET_NETDEV_DEV(dev, &pdev->dev);
 286
 287        /* Reset card. Who knows what dain-bramaged state it was left in. */
 288        {
 289                unsigned long reset_start_time = jiffies;
 290
 291                outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
 292
 293                /* This looks like a horrible timing loop, but it should never take
 294                   more than a few cycles.
 295                */
 296                while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
 297                        /* Limit wait: '2' avoids jiffy roll-over. */
 298                        if (jiffies - reset_start_time > 2) {
 299                                dev_err(&pdev->dev,
 300                                        "Card failure (no reset ack).\n");
 301                                goto err_out_free_netdev;
 302                        }
 303
 304                outb(0xff, ioaddr + EN0_ISR);           /* Ack all intr. */
 305        }
 306
 307        /* Read the 16 bytes of station address PROM.
 308           We must first initialize registers, similar to NS8390_init(eifdev, 0).
 309           We can't reliably read the SAPROM address without this.
 310           (I learned the hard way!). */
 311        {
 312                struct {unsigned char value, offset; } program_seq[] = {
 313                        {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 314                        {0x49,  EN0_DCFG},      /* Set word-wide access. */
 315                        {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 316                        {0x00,  EN0_RCNTHI},
 317                        {0x00,  EN0_IMR},       /* Mask completion irq. */
 318                        {0xFF,  EN0_ISR},
 319                        {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
 320                        {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 321                        {32,    EN0_RCNTLO},
 322                        {0x00,  EN0_RCNTHI},
 323                        {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
 324                        {0x00,  EN0_RSARHI},
 325                        {E8390_RREAD+E8390_START, E8390_CMD},
 326                };
 327                for (i = 0; i < ARRAY_SIZE(program_seq); i++)
 328                        outb(program_seq[i].value, ioaddr + program_seq[i].offset);
 329
 330        }
 331
 332        /* Note: all PCI cards have at least 16 bit access, so we don't have
 333           to check for 8 bit cards.  Most cards permit 32 bit access. */
 334        if (flags & ONLY_32BIT_IO) {
 335                for (i = 0; i < 4 ; i++)
 336                        ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
 337        } else
 338                for(i = 0; i < 32 /*sizeof(SA_prom)*/; i++)
 339                        SA_prom[i] = inb(ioaddr + NE_DATAPORT);
 340
 341        /* We always set the 8390 registers for word mode. */
 342        outb(0x49, ioaddr + EN0_DCFG);
 343        start_page = NESM_START_PG;
 344
 345        stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
 346
 347        /* Set up the rest of the parameters. */
 348        dev->irq = irq;
 349        dev->base_addr = ioaddr;
 350        pci_set_drvdata(pdev, dev);
 351
 352        ei_status.name = pci_clone_list[chip_idx].name;
 353        ei_status.tx_start_page = start_page;
 354        ei_status.stop_page = stop_page;
 355        ei_status.word16 = 1;
 356        ei_status.ne2k_flags = flags;
 357        if (fnd_cnt < MAX_UNITS) {
 358                if (full_duplex[fnd_cnt] > 0  ||  (options[fnd_cnt] & FORCE_FDX))
 359                        ei_status.ne2k_flags |= FORCE_FDX;
 360        }
 361
 362        ei_status.rx_start_page = start_page + TX_PAGES;
 363#ifdef PACKETBUF_MEMSIZE
 364        /* Allow the packet buffer size to be overridden by know-it-alls. */
 365        ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
 366#endif
 367
 368        ei_status.reset_8390 = &ne2k_pci_reset_8390;
 369        ei_status.block_input = &ne2k_pci_block_input;
 370        ei_status.block_output = &ne2k_pci_block_output;
 371        ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
 372        ei_status.priv = (unsigned long) pdev;
 373
 374        dev->ethtool_ops = &ne2k_pci_ethtool_ops;
 375        NS8390_init(dev, 0);
 376
 377        memcpy(dev->dev_addr, SA_prom, dev->addr_len);
 378        memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 379
 380        i = register_netdev(dev);
 381        if (i)
 382                goto err_out_free_netdev;
 383
 384        printk("%s: %s found at %#lx, IRQ %d, %pM.\n",
 385               dev->name, pci_clone_list[chip_idx].name, ioaddr, dev->irq,
 386               dev->dev_addr);
 387
 388        return 0;
 389
 390err_out_free_netdev:
 391        free_netdev (dev);
 392err_out_free_res:
 393        release_region (ioaddr, NE_IO_EXTENT);
 394        pci_set_drvdata (pdev, NULL);
 395        return -ENODEV;
 396
 397}
 398
 399/*
 400 * Magic incantation sequence for full duplex on the supported cards.
 401 */
 402static inline int set_realtek_fdx(struct net_device *dev)
 403{
 404        long ioaddr = dev->base_addr;
 405
 406        outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
 407        outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
 408        outb(0x40, ioaddr + 0x06); /* Enable full duplex */
 409        outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
 410        outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
 411        return 0;
 412}
 413
 414static inline int set_holtek_fdx(struct net_device *dev)
 415{
 416        long ioaddr = dev->base_addr;
 417
 418        outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
 419        return 0;
 420}
 421
 422static int ne2k_pci_set_fdx(struct net_device *dev)
 423{
 424        if (ei_status.ne2k_flags & REALTEK_FDX)
 425                return set_realtek_fdx(dev);
 426        else if (ei_status.ne2k_flags & HOLTEK_FDX)
 427                return set_holtek_fdx(dev);
 428
 429        return -EOPNOTSUPP;
 430}
 431
 432static int ne2k_pci_open(struct net_device *dev)
 433{
 434        int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED, dev->name, dev);
 435        if (ret)
 436                return ret;
 437
 438        if (ei_status.ne2k_flags & FORCE_FDX)
 439                ne2k_pci_set_fdx(dev);
 440
 441        ei_open(dev);
 442        return 0;
 443}
 444
 445static int ne2k_pci_close(struct net_device *dev)
 446{
 447        ei_close(dev);
 448        free_irq(dev->irq, dev);
 449        return 0;
 450}
 451
 452/* Hard reset the card.  This used to pause for the same period that a
 453   8390 reset command required, but that shouldn't be necessary. */
 454static void ne2k_pci_reset_8390(struct net_device *dev)
 455{
 456        unsigned long reset_start_time = jiffies;
 457
 458        if (debug > 1) printk("%s: Resetting the 8390 t=%ld...",
 459                                                  dev->name, jiffies);
 460
 461        outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
 462
 463        ei_status.txing = 0;
 464        ei_status.dmaing = 0;
 465
 466        /* This check _should_not_ be necessary, omit eventually. */
 467        while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
 468                if (jiffies - reset_start_time > 2) {
 469                        printk("%s: ne2k_pci_reset_8390() did not complete.\n", dev->name);
 470                        break;
 471                }
 472        outb(ENISR_RESET, NE_BASE + EN0_ISR);   /* Ack intr. */
 473}
 474
 475/* Grab the 8390 specific header. Similar to the block_input routine, but
 476   we don't need to be concerned with ring wrap as the header will be at
 477   the start of a page, so we optimize accordingly. */
 478
 479static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 480{
 481
 482        long nic_base = dev->base_addr;
 483
 484        /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 485        if (ei_status.dmaing) {
 486                printk("%s: DMAing conflict in ne2k_pci_get_8390_hdr "
 487                           "[DMAstat:%d][irqlock:%d].\n",
 488                           dev->name, ei_status.dmaing, ei_status.irqlock);
 489                return;
 490        }
 491
 492        ei_status.dmaing |= 0x01;
 493        outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 494        outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
 495        outb(0, nic_base + EN0_RCNTHI);
 496        outb(0, nic_base + EN0_RSARLO);         /* On page boundary */
 497        outb(ring_page, nic_base + EN0_RSARHI);
 498        outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 499
 500        if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 501                insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
 502        } else {
 503                *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
 504                le16_to_cpus(&hdr->count);
 505        }
 506
 507        outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 508        ei_status.dmaing &= ~0x01;
 509}
 510
 511/* Block input and output, similar to the Crynwr packet driver.  If you
 512   are porting to a new ethercard, look at the packet driver source for hints.
 513   The NEx000 doesn't share the on-board packet memory -- you have to put
 514   the packet out through the "remote DMA" dataport using outb. */
 515
 516static void ne2k_pci_block_input(struct net_device *dev, int count,
 517                                 struct sk_buff *skb, int ring_offset)
 518{
 519        long nic_base = dev->base_addr;
 520        char *buf = skb->data;
 521
 522        /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 523        if (ei_status.dmaing) {
 524                printk("%s: DMAing conflict in ne2k_pci_block_input "
 525                           "[DMAstat:%d][irqlock:%d].\n",
 526                           dev->name, ei_status.dmaing, ei_status.irqlock);
 527                return;
 528        }
 529        ei_status.dmaing |= 0x01;
 530        if (ei_status.ne2k_flags & ONLY_32BIT_IO)
 531                count = (count + 3) & 0xFFFC;
 532        outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 533        outb(count & 0xff, nic_base + EN0_RCNTLO);
 534        outb(count >> 8, nic_base + EN0_RCNTHI);
 535        outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
 536        outb(ring_offset >> 8, nic_base + EN0_RSARHI);
 537        outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 538
 539        if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 540                insw(NE_BASE + NE_DATAPORT,buf,count>>1);
 541                if (count & 0x01) {
 542                        buf[count-1] = inb(NE_BASE + NE_DATAPORT);
 543                }
 544        } else {
 545                insl(NE_BASE + NE_DATAPORT, buf, count>>2);
 546                if (count & 3) {
 547                        buf += count & ~3;
 548                        if (count & 2) {
 549                                __le16 *b = (__le16 *)buf;
 550
 551                                *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
 552                                buf = (char *)b;
 553                        }
 554                        if (count & 1)
 555                                *buf = inb(NE_BASE + NE_DATAPORT);
 556                }
 557        }
 558
 559        outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 560        ei_status.dmaing &= ~0x01;
 561}
 562
 563static void ne2k_pci_block_output(struct net_device *dev, int count,
 564                                  const unsigned char *buf, const int start_page)
 565{
 566        long nic_base = NE_BASE;
 567        unsigned long dma_start;
 568
 569        /* On little-endian it's always safe to round the count up for
 570           word writes. */
 571        if (ei_status.ne2k_flags & ONLY_32BIT_IO)
 572                count = (count + 3) & 0xFFFC;
 573        else
 574                if (count & 0x01)
 575                        count++;
 576
 577        /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 578        if (ei_status.dmaing) {
 579                printk("%s: DMAing conflict in ne2k_pci_block_output."
 580                           "[DMAstat:%d][irqlock:%d]\n",
 581                           dev->name, ei_status.dmaing, ei_status.irqlock);
 582                return;
 583        }
 584        ei_status.dmaing |= 0x01;
 585        /* We should already be in page 0, but to be safe... */
 586        outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
 587
 588#ifdef NE8390_RW_BUGFIX
 589        /* Handle the read-before-write bug the same way as the
 590           Crynwr packet driver -- the NatSemi method doesn't work.
 591           Actually this doesn't always work either, but if you have
 592           problems with your NEx000 this is better than nothing! */
 593        outb(0x42, nic_base + EN0_RCNTLO);
 594        outb(0x00, nic_base + EN0_RCNTHI);
 595        outb(0x42, nic_base + EN0_RSARLO);
 596        outb(0x00, nic_base + EN0_RSARHI);
 597        outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 598#endif
 599        outb(ENISR_RDC, nic_base + EN0_ISR);
 600
 601   /* Now the normal output. */
 602        outb(count & 0xff, nic_base + EN0_RCNTLO);
 603        outb(count >> 8,   nic_base + EN0_RCNTHI);
 604        outb(0x00, nic_base + EN0_RSARLO);
 605        outb(start_page, nic_base + EN0_RSARHI);
 606        outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
 607        if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
 608                outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
 609        } else {
 610                outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
 611                if (count & 3) {
 612                        buf += count & ~3;
 613                        if (count & 2) {
 614                                __le16 *b = (__le16 *)buf;
 615
 616                                outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
 617                                buf = (char *)b;
 618                        }
 619                }
 620        }
 621
 622        dma_start = jiffies;
 623
 624        while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
 625                if (jiffies - dma_start > 2) {                  /* Avoid clock roll-over. */
 626                        printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
 627                        ne2k_pci_reset_8390(dev);
 628                        NS8390_init(dev,1);
 629                        break;
 630                }
 631
 632        outb(ENISR_RDC, nic_base + EN0_ISR);    /* Ack intr. */
 633        ei_status.dmaing &= ~0x01;
 634}
 635
 636static void ne2k_pci_get_drvinfo(struct net_device *dev,
 637                                 struct ethtool_drvinfo *info)
 638{
 639        struct ei_device *ei = netdev_priv(dev);
 640        struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
 641
 642        strcpy(info->driver, DRV_NAME);
 643        strcpy(info->version, DRV_VERSION);
 644        strcpy(info->bus_info, pci_name(pci_dev));
 645}
 646
 647static const struct ethtool_ops ne2k_pci_ethtool_ops = {
 648        .get_drvinfo            = ne2k_pci_get_drvinfo,
 649};
 650
 651static void __devexit ne2k_pci_remove_one (struct pci_dev *pdev)
 652{
 653        struct net_device *dev = pci_get_drvdata(pdev);
 654
 655        BUG_ON(!dev);
 656        unregister_netdev(dev);
 657        release_region(dev->base_addr, NE_IO_EXTENT);
 658        free_netdev(dev);
 659        pci_disable_device(pdev);
 660        pci_set_drvdata(pdev, NULL);
 661}
 662
 663#ifdef CONFIG_PM
 664static int ne2k_pci_suspend (struct pci_dev *pdev, pm_message_t state)
 665{
 666        struct net_device *dev = pci_get_drvdata (pdev);
 667
 668        netif_device_detach(dev);
 669        pci_save_state(pdev);
 670        pci_disable_device(pdev);
 671        pci_set_power_state(pdev, pci_choose_state(pdev, state));
 672
 673        return 0;
 674}
 675
 676static int ne2k_pci_resume (struct pci_dev *pdev)
 677{
 678        struct net_device *dev = pci_get_drvdata (pdev);
 679        int rc;
 680
 681        pci_set_power_state(pdev, 0);
 682        pci_restore_state(pdev);
 683
 684        rc = pci_enable_device(pdev);
 685        if (rc)
 686                return rc;
 687
 688        NS8390_init(dev, 1);
 689        netif_device_attach(dev);
 690
 691        return 0;
 692}
 693
 694#endif /* CONFIG_PM */
 695
 696
 697static struct pci_driver ne2k_driver = {
 698        .name           = DRV_NAME,
 699        .probe          = ne2k_pci_init_one,
 700        .remove         = __devexit_p(ne2k_pci_remove_one),
 701        .id_table       = ne2k_pci_tbl,
 702#ifdef CONFIG_PM
 703        .suspend        = ne2k_pci_suspend,
 704        .resume         = ne2k_pci_resume,
 705#endif /* CONFIG_PM */
 706
 707};
 708
 709
 710static int __init ne2k_pci_init(void)
 711{
 712/* when a module, this is printed whether or not devices are found in probe */
 713#ifdef MODULE
 714        printk(version);
 715#endif
 716        return pci_register_driver(&ne2k_driver);
 717}
 718
 719
 720static void __exit ne2k_pci_cleanup(void)
 721{
 722        pci_unregister_driver (&ne2k_driver);
 723}
 724
 725module_init(ne2k_pci_init);
 726module_exit(ne2k_pci_cleanup);
 727