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