drivers/net/ethernet/8390/ne2k-pci.c

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