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