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