![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ne.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to ne.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 ! root 1: /* ne.c: A general non-shared-memory NS8390 ethernet driver for linux. */ ! 2: /* ! 3: Written 1992-94 by Donald Becker. ! 4: ! 5: Copyright 1993 United States Government as represented by the ! 6: Director, National Security Agency. ! 7: ! 8: This software may be used and distributed according to the terms ! 9: of the GNU Public License, incorporated herein by reference. ! 10: ! 11: The author may be reached as [email protected], or C/O ! 12: Center of Excellence in Space Data and Information Sciences ! 13: Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771 ! 14: ! 15: This driver should work with many programmed-I/O 8390-based ethernet ! 16: boards. Currently it supports the NE1000, NE2000, many clones, ! 17: and some Cabletron products. ! 18: ! 19: Changelog: ! 20: ! 21: Paul Gortmaker : use ENISR_RDC to monitor Tx PIO uploads, made ! 22: sanity checks and bad clone support optional. ! 23: Paul Gortmaker : new reset code, reset card after probe at boot. ! 24: Paul Gortmaker : multiple card support for module users. ! 25: Paul Gortmaker : Support for PCI ne2k clones, similar to lance.c ! 26: Paul Gortmaker : Allow users with bad cards to avoid full probe. ! 27: Paul Gortmaker : PCI probe changes, more PCI cards supported. ! 28: ! 29: */ ! 30: ! 31: /* Routines for the NatSemi-based designs (NE[12]000). */ ! 32: ! 33: static const char *version = ! 34: "ne.c:v1.10 9/23/94 Donald Becker ([email protected])\n"; ! 35: ! 36: ! 37: #include <linux/module.h> ! 38: #include <linux/config.h> ! 39: #include <linux/kernel.h> ! 40: #include <linux/sched.h> ! 41: #include <linux/errno.h> ! 42: #include <linux/pci.h> ! 43: #include <linux/bios32.h> ! 44: #include <asm/system.h> ! 45: #include <asm/io.h> ! 46: ! 47: #include <linux/netdevice.h> ! 48: #include <linux/etherdevice.h> ! 49: #include "8390.h" ! 50: ! 51: /* Some defines that people can play with if so inclined. */ ! 52: ! 53: /* Do we support clones that don't adhere to 14,15 of the SAprom ? */ ! 54: #define SUPPORT_NE_BAD_CLONES ! 55: ! 56: /* Do we perform extra sanity checks on stuff ? */ ! 57: /* #define NE_SANITY_CHECK */ ! 58: ! 59: /* Do we implement the read before write bugfix ? */ ! 60: /* #define NE_RW_BUGFIX */ ! 61: ! 62: /* Do we have a non std. amount of memory? (in units of 256 byte pages) */ ! 63: /* #define PACKETBUF_MEMSIZE 0x40 */ ! 64: ! 65: #if defined(HAVE_DEVLIST) || !defined(MODULE) ! 66: /* A zero-terminated list of I/O addresses to be probed. */ ! 67: static unsigned int netcard_portlist[] = ! 68: { 0x300, 0x280, 0x320, 0x340, 0x360, 0}; ! 69: #endif /* defined(HAVE_DEVLIST) || !defined(MODULE) */ ! 70: ! 71: #ifdef CONFIG_PCI ! 72: /* Ack! People are making PCI ne2000 clones! Oh the horror, the horror... */ ! 73: static struct { unsigned short vendor, dev_id;} ! 74: pci_clone_list[] = { ! 75: {PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8029}, ! 76: {PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_89C940}, ! 77: {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_RL2000}, ! 78: {PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_ET32P2}, ! 79: {PCI_VENDOR_ID_NETVIN, PCI_DEVICE_ID_NETVIN_NV5000SC}, ! 80: {PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C926}, ! 81: {0,} ! 82: }; ! 83: #endif ! 84: ! 85: #ifdef SUPPORT_NE_BAD_CLONES ! 86: /* A list of bad clones that we none-the-less recognize. */ ! 87: static struct { const char *name8, *name16; unsigned char SAprefix[4];} ! 88: bad_clone_list[] = { ! 89: {"DE100", "DE200", {0x00, 0xDE, 0x01,}}, ! 90: {"DE120", "DE220", {0x00, 0x80, 0xc8,}}, ! 91: {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */ ! 92: {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}}, ! 93: {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */ ! 94: {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */ ! 95: {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */ ! 96: {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */ ! 97: {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */ ! 98: {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */ ! 99: {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */ ! 100: {0,} ! 101: }; ! 102: #endif ! 103: ! 104: /* ---- No user-serviceable parts below ---- */ ! 105: ! 106: #define NE_BASE (dev->base_addr) ! 107: #define NE_CMD 0x00 ! 108: #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */ ! 109: #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */ ! 110: #define NE_IO_EXTENT 0x20 ! 111: ! 112: #define NE1SM_START_PG 0x20 /* First page of TX buffer */ ! 113: #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */ ! 114: #define NESM_START_PG 0x40 /* First page of TX buffer */ ! 115: #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ ! 116: ! 117: /* Non-zero only if the current card is a PCI with BIOS-set IRQ. */ ! 118: static unsigned char pci_irq_line = 0; ! 119: ! 120: int ne_probe(struct device *dev); ! 121: #ifdef CONFIG_PCI ! 122: static int ne_probe_pci(struct device *dev); ! 123: #endif ! 124: static int ne_probe1(struct device *dev, int ioaddr); ! 125: ! 126: static int ne_open(struct device *dev); ! 127: static int ne_close(struct device *dev); ! 128: ! 129: static void ne_reset_8390(struct device *dev); ! 130: static void ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, ! 131: int ring_page); ! 132: static void ne_block_input(struct device *dev, int count, ! 133: struct sk_buff *skb, int ring_offset); ! 134: static void ne_block_output(struct device *dev, const int count, ! 135: const unsigned char *buf, const int start_page); ! 136: ! 137: ! 138: /* Probe for various non-shared-memory ethercards. ! 139: ! 140: NEx000-clone boards have a Station Address PROM (SAPROM) in the packet ! 141: buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of ! 142: the SAPROM, while other supposed NE2000 clones must be detected by their ! 143: SA prefix. ! 144: ! 145: Reading the SAPROM from a word-wide card with the 8390 set in byte-wide ! 146: mode results in doubled values, which can be detected and compensated for. ! 147: ! 148: The probe is also responsible for initializing the card and filling ! 149: in the 'dev' and 'ei_status' structures. ! 150: ! 151: We use the minimum memory size for some ethercard product lines, iff we can't ! 152: distinguish models. You can increase the packet buffer size by setting ! 153: PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are: ! 154: E1010 starts at 0x100 and ends at 0x2000. ! 155: E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory") ! 156: E2010 starts at 0x100 and ends at 0x4000. ! 157: E2010-x starts at 0x100 and ends at 0xffff. */ ! 158: ! 159: #ifdef HAVE_DEVLIST ! 160: struct netdev_entry netcard_drv = ! 161: {"ne", ne_probe1, NE_IO_EXTENT, netcard_portlist}; ! 162: #else ! 163: ! 164: /* Note that this probe only picks up one card at a time, even for multiple ! 165: PCI ne2k cards. Use "ether=0,0,eth1" if you have a second PCI ne2k card. ! 166: This keeps things consistent regardless of the bus type of the card. */ ! 167: ! 168: int ne_probe(struct device *dev) ! 169: { ! 170: #ifndef MODULE ! 171: int i; ! 172: #endif /* MODULE */ ! 173: int base_addr = dev ? dev->base_addr : 0; ! 174: ! 175: /* First check any supplied i/o locations. User knows best. <cough> */ ! 176: if (base_addr > 0x1ff) /* Check a single specified location. */ ! 177: return ne_probe1(dev, base_addr); ! 178: else if (base_addr != 0) /* Don't probe at all. */ ! 179: return ENXIO; ! 180: ! 181: #ifdef CONFIG_PCI ! 182: /* Then look for any installed PCI clones */ ! 183: if (pcibios_present() && (ne_probe_pci(dev) == 0)) ! 184: return 0; ! 185: #endif ! 186: ! 187: #ifndef MODULE ! 188: /* Last resort. The semi-risky ISA auto-probe. */ ! 189: for (i = 0; netcard_portlist[i]; i++) { ! 190: int ioaddr = netcard_portlist[i]; ! 191: if (check_region(ioaddr, NE_IO_EXTENT)) ! 192: continue; ! 193: if (ne_probe1(dev, ioaddr) == 0) ! 194: return 0; ! 195: } ! 196: #endif ! 197: ! 198: return ENODEV; ! 199: } ! 200: #endif ! 201: ! 202: #ifdef CONFIG_PCI ! 203: static int ne_probe_pci(struct device *dev) ! 204: { ! 205: int i; ! 206: ! 207: for (i = 0; pci_clone_list[i].vendor != 0; i++) { ! 208: unsigned char pci_bus, pci_device_fn; ! 209: unsigned int pci_ioaddr; ! 210: u16 pci_command, new_command; ! 211: int pci_index; ! 212: ! 213: for (pci_index = 0; pci_index < 8; pci_index++) { ! 214: if (pcibios_find_device (pci_clone_list[i].vendor, ! 215: pci_clone_list[i].dev_id, pci_index, ! 216: &pci_bus, &pci_device_fn) != 0) ! 217: break; /* No more of these type of cards */ ! 218: pcibios_read_config_dword(pci_bus, pci_device_fn, ! 219: PCI_BASE_ADDRESS_0, &pci_ioaddr); ! 220: /* Strip the I/O address out of the returned value */ ! 221: pci_ioaddr &= PCI_BASE_ADDRESS_IO_MASK; ! 222: /* Avoid already found cards from previous calls */ ! 223: if (check_region(pci_ioaddr, NE_IO_EXTENT)) ! 224: continue; ! 225: pcibios_read_config_byte(pci_bus, pci_device_fn, ! 226: PCI_INTERRUPT_LINE, &pci_irq_line); ! 227: break; /* Beauty -- got a valid card. */ ! 228: } ! 229: if (pci_irq_line == 0) continue; /* Try next PCI ID */ ! 230: printk("ne.c: PCI BIOS reports NE 2000 clone at i/o %#x, irq %d.\n", ! 231: pci_ioaddr, pci_irq_line); ! 232: ! 233: pcibios_read_config_word(pci_bus, pci_device_fn, ! 234: PCI_COMMAND, &pci_command); ! 235: ! 236: /* Activate the card: fix for brain-damaged Win98 BIOSes. */ ! 237: new_command = pci_command | PCI_COMMAND_IO; ! 238: if (pci_command != new_command) { ! 239: printk(KERN_INFO " The PCI BIOS has not enabled this" ! 240: " NE2k clone! Updating PCI command %4.4x->%4.4x.\n", ! 241: pci_command, new_command); ! 242: pcibios_write_config_word(pci_bus, pci_device_fn, ! 243: PCI_COMMAND, new_command); ! 244: } ! 245: ! 246: if (ne_probe1(dev, pci_ioaddr) != 0) { /* Shouldn't happen. */ ! 247: printk(KERN_ERR "ne.c: Probe of PCI card at %#x failed.\n", pci_ioaddr); ! 248: pci_irq_line = 0; ! 249: return -ENXIO; ! 250: } ! 251: pci_irq_line = 0; ! 252: return 0; ! 253: } ! 254: return -ENODEV; ! 255: } ! 256: #endif /* CONFIG_PCI */ ! 257: ! 258: static int ne_probe1(struct device *dev, int ioaddr) ! 259: { ! 260: int i; ! 261: unsigned char SA_prom[32]; ! 262: int wordlength = 2; ! 263: const char *name = NULL; ! 264: int start_page, stop_page; ! 265: int neX000, ctron, bad_card; ! 266: int reg0 = inb_p(ioaddr); ! 267: static unsigned version_printed = 0; ! 268: ! 269: if (reg0 == 0xFF) ! 270: return ENODEV; ! 271: ! 272: /* Do a preliminary verification that we have a 8390. */ ! 273: { int regd; ! 274: outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD); ! 275: regd = inb_p(ioaddr + 0x0d); ! 276: outb_p(0xff, ioaddr + 0x0d); ! 277: outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD); ! 278: inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */ ! 279: if (inb_p(ioaddr + EN0_COUNTER0) != 0) { ! 280: outb_p(reg0, ioaddr); ! 281: outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */ ! 282: return ENODEV; ! 283: } ! 284: } ! 285: ! 286: /* We should have a "dev" from Space.c or the static module table. */ ! 287: if (dev == NULL) { ! 288: printk(KERN_ERR "ne.c: Passed a NULL device.\n"); ! 289: dev = init_etherdev(0, 0); ! 290: } ! 291: ! 292: if (ei_debug && version_printed++ == 0) ! 293: printk(version); ! 294: ! 295: printk("NE*000 ethercard probe at %#3x:", ioaddr); ! 296: ! 297: /* A user with a poor card that fails to ack the reset, or that ! 298: does not have a valid 0x57,0x57 signature can still use this ! 299: without having to recompile. Specifying an i/o address along ! 300: with an otherwise unused dev->mem_end value of "0xBAD" will ! 301: cause the driver to skip these parts of the probe. */ ! 302: ! 303: bad_card = ((dev->base_addr != 0) && (dev->mem_end == 0xbad)); ! 304: ! 305: /* Reset card. Who knows what dain-bramaged state it was left in. */ ! 306: { unsigned long reset_start_time = jiffies; ! 307: ! 308: /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ ! 309: outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET); ! 310: ! 311: while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0) ! 312: if (jiffies - reset_start_time > 2*HZ/100) { ! 313: if (bad_card) { ! 314: printk(" (warning: no reset ack)"); ! 315: break; ! 316: } else { ! 317: printk(" not found (no reset ack).\n"); ! 318: return ENODEV; ! 319: } ! 320: } ! 321: ! 322: outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */ ! 323: } ! 324: ! 325: /* Read the 16 bytes of station address PROM. ! 326: We must first initialize registers, similar to NS8390_init(eifdev, 0). ! 327: We can't reliably read the SAPROM address without this. ! 328: (I learned the hard way!). */ ! 329: { ! 330: struct {unsigned char value, offset; } program_seq[] = { ! 331: {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/ ! 332: {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */ ! 333: {0x00, EN0_RCNTLO}, /* Clear the count regs. */ ! 334: {0x00, EN0_RCNTHI}, ! 335: {0x00, EN0_IMR}, /* Mask completion irq. */ ! 336: {0xFF, EN0_ISR}, ! 337: {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */ ! 338: {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */ ! 339: {32, EN0_RCNTLO}, ! 340: {0x00, EN0_RCNTHI}, ! 341: {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */ ! 342: {0x00, EN0_RSARHI}, ! 343: {E8390_RREAD+E8390_START, E8390_CMD}, ! 344: }; ! 345: for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) ! 346: outb_p(program_seq[i].value, ioaddr + program_seq[i].offset); ! 347: ! 348: } ! 349: for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) { ! 350: SA_prom[i] = inb(ioaddr + NE_DATAPORT); ! 351: SA_prom[i+1] = inb(ioaddr + NE_DATAPORT); ! 352: if (SA_prom[i] != SA_prom[i+1]) ! 353: wordlength = 1; ! 354: } ! 355: ! 356: /* At this point, wordlength *only* tells us if the SA_prom is doubled ! 357: up or not because some broken PCI cards don't respect the byte-wide ! 358: request in program_seq above, and hence don't have doubled up values. ! 359: These broken cards would otherwise be detected as an ne1000. */ ! 360: ! 361: if (wordlength == 2) ! 362: for (i = 0; i < 16; i++) ! 363: SA_prom[i] = SA_prom[i+i]; ! 364: ! 365: if (pci_irq_line || ioaddr >= 0x400) ! 366: wordlength = 2; /* Catch broken PCI cards mentioned above. */ ! 367: ! 368: if (wordlength == 2) { ! 369: /* We must set the 8390 for word mode. */ ! 370: outb_p(0x49, ioaddr + EN0_DCFG); ! 371: start_page = NESM_START_PG; ! 372: stop_page = NESM_STOP_PG; ! 373: } else { ! 374: start_page = NE1SM_START_PG; ! 375: stop_page = NE1SM_STOP_PG; ! 376: } ! 377: ! 378: neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57); ! 379: ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d); ! 380: ! 381: /* Set up the rest of the parameters. */ ! 382: if (neX000 || bad_card) { ! 383: name = (wordlength == 2) ? "NE2000" : "NE1000"; ! 384: } else if (ctron) { ! 385: name = (wordlength == 2) ? "Ctron-8" : "Ctron-16"; ! 386: start_page = 0x01; ! 387: stop_page = (wordlength == 2) ? 0x40 : 0x20; ! 388: } else { ! 389: #ifdef SUPPORT_NE_BAD_CLONES ! 390: /* Ack! Well, there might be a *bad* NE*000 clone there. ! 391: Check for total bogus addresses. */ ! 392: for (i = 0; bad_clone_list[i].name8; i++) { ! 393: if (SA_prom[0] == bad_clone_list[i].SAprefix[0] && ! 394: SA_prom[1] == bad_clone_list[i].SAprefix[1] && ! 395: SA_prom[2] == bad_clone_list[i].SAprefix[2]) { ! 396: if (wordlength == 2) { ! 397: name = bad_clone_list[i].name16; ! 398: } else { ! 399: name = bad_clone_list[i].name8; ! 400: } ! 401: break; ! 402: } ! 403: } ! 404: if (bad_clone_list[i].name8 == NULL) { ! 405: printk(" not found (invalid signature %2.2x %2.2x).\n", ! 406: SA_prom[14], SA_prom[15]); ! 407: return ENXIO; ! 408: } ! 409: #else ! 410: printk(" not found.\n"); ! 411: return ENXIO; ! 412: #endif ! 413: ! 414: } ! 415: ! 416: if (pci_irq_line) ! 417: dev->irq = pci_irq_line; ! 418: ! 419: if (dev->irq < 2) { ! 420: autoirq_setup(0); ! 421: outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */ ! 422: outb_p(0x00, ioaddr + EN0_RCNTLO); ! 423: outb_p(0x00, ioaddr + EN0_RCNTHI); ! 424: outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */ ! 425: outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */ ! 426: dev->irq = autoirq_report(0); ! 427: if (ei_debug > 2) ! 428: printk(" autoirq is %d\n", dev->irq); ! 429: } else if (dev->irq == 2) ! 430: /* Fixup for users that don't know that IRQ 2 is really IRQ 9, ! 431: or don't know which one to set. */ ! 432: dev->irq = 9; ! 433: ! 434: if (! dev->irq) { ! 435: printk(" failed to detect IRQ line.\n"); ! 436: return EAGAIN; ! 437: } ! 438: ! 439: /* Snarf the interrupt now. There's no point in waiting since we cannot ! 440: share (with ISA cards) and the board will usually be enabled. */ ! 441: { ! 442: int irqval = request_irq(dev->irq, ei_interrupt, ! 443: pci_irq_line ? SA_SHIRQ : 0, name, dev); ! 444: if (irqval) { ! 445: printk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval); ! 446: return EAGAIN; ! 447: } ! 448: } ! 449: ! 450: dev->base_addr = ioaddr; ! 451: ! 452: /* Allocate dev->priv and fill in 8390 specific dev fields. */ ! 453: if (ethdev_init(dev)) { ! 454: printk (" unable to get memory for dev->priv.\n"); ! 455: free_irq(dev->irq, NULL); ! 456: return -ENOMEM; ! 457: } ! 458: ! 459: request_region(ioaddr, NE_IO_EXTENT, name); ! 460: ! 461: for(i = 0; i < ETHER_ADDR_LEN; i++) { ! 462: printk(" %2.2x", SA_prom[i]); ! 463: dev->dev_addr[i] = SA_prom[i]; ! 464: } ! 465: ! 466: printk("\n%s: %s found at %#x, using IRQ %d.\n", ! 467: dev->name, name, ioaddr, dev->irq); ! 468: ! 469: ei_status.name = name; ! 470: ei_status.tx_start_page = start_page; ! 471: ei_status.stop_page = stop_page; ! 472: ei_status.word16 = (wordlength == 2); ! 473: ! 474: ei_status.rx_start_page = start_page + TX_PAGES; ! 475: #ifdef PACKETBUF_MEMSIZE ! 476: /* Allow the packet buffer size to be overridden by know-it-alls. */ ! 477: ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE; ! 478: #endif ! 479: ! 480: ei_status.reset_8390 = &ne_reset_8390; ! 481: ei_status.block_input = &ne_block_input; ! 482: ei_status.block_output = &ne_block_output; ! 483: ei_status.get_8390_hdr = &ne_get_8390_hdr; ! 484: dev->open = &ne_open; ! 485: dev->stop = &ne_close; ! 486: NS8390_init(dev, 0); ! 487: return 0; ! 488: } ! 489: ! 490: static int ! 491: ne_open(struct device *dev) ! 492: { ! 493: ei_open(dev); ! 494: MOD_INC_USE_COUNT; ! 495: return 0; ! 496: } ! 497: ! 498: static int ! 499: ne_close(struct device *dev) ! 500: { ! 501: if (ei_debug > 1) ! 502: printk("%s: Shutting down ethercard.\n", dev->name); ! 503: ei_close(dev); ! 504: MOD_DEC_USE_COUNT; ! 505: return 0; ! 506: } ! 507: ! 508: /* Hard reset the card. This used to pause for the same period that a ! 509: 8390 reset command required, but that shouldn't be necessary. */ ! 510: static void ! 511: ne_reset_8390(struct device *dev) ! 512: { ! 513: unsigned long reset_start_time = jiffies; ! 514: ! 515: if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies); ! 516: ! 517: /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ ! 518: outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); ! 519: ! 520: ei_status.txing = 0; ! 521: ei_status.dmaing = 0; ! 522: ! 523: /* This check _should_not_ be necessary, omit eventually. */ ! 524: while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0) ! 525: if (jiffies - reset_start_time > 2*HZ/100) { ! 526: printk("%s: ne_reset_8390() did not complete.\n", dev->name); ! 527: break; ! 528: } ! 529: outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */ ! 530: } ! 531: ! 532: /* Grab the 8390 specific header. Similar to the block_input routine, but ! 533: we don't need to be concerned with ring wrap as the header will be at ! 534: the start of a page, so we optimize accordingly. */ ! 535: ! 536: static void ! 537: ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page) ! 538: { ! 539: ! 540: int nic_base = dev->base_addr; ! 541: ! 542: /* This *shouldn't* happen. If it does, it's the last thing you'll see */ ! 543: if (ei_status.dmaing) { ! 544: printk("%s: DMAing conflict in ne_get_8390_hdr " ! 545: "[DMAstat:%d][irqlock:%d][intr:%d].\n", ! 546: dev->name, ei_status.dmaing, ei_status.irqlock, ! 547: dev->interrupt); ! 548: return; ! 549: } ! 550: ! 551: ei_status.dmaing |= 0x01; ! 552: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); ! 553: outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO); ! 554: outb_p(0, nic_base + EN0_RCNTHI); ! 555: outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */ ! 556: outb_p(ring_page, nic_base + EN0_RSARHI); ! 557: outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); ! 558: ! 559: if (ei_status.word16) ! 560: insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1); ! 561: else ! 562: insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)); ! 563: ! 564: outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ ! 565: ei_status.dmaing &= ~0x01; ! 566: } ! 567: ! 568: /* Block input and output, similar to the Crynwr packet driver. If you ! 569: are porting to a new ethercard, look at the packet driver source for hints. ! 570: The NEx000 doesn't share the on-board packet memory -- you have to put ! 571: the packet out through the "remote DMA" dataport using outb. */ ! 572: ! 573: static void ! 574: ne_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset) ! 575: { ! 576: #ifdef NE_SANITY_CHECK ! 577: int xfer_count = count; ! 578: #endif ! 579: int nic_base = dev->base_addr; ! 580: char *buf = skb->data; ! 581: ! 582: /* This *shouldn't* happen. If it does, it's the last thing you'll see */ ! 583: if (ei_status.dmaing) { ! 584: printk("%s: DMAing conflict in ne_block_input " ! 585: "[DMAstat:%d][irqlock:%d][intr:%d].\n", ! 586: dev->name, ei_status.dmaing, ei_status.irqlock, ! 587: dev->interrupt); ! 588: return; ! 589: } ! 590: ei_status.dmaing |= 0x01; ! 591: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); ! 592: outb_p(count & 0xff, nic_base + EN0_RCNTLO); ! 593: outb_p(count >> 8, nic_base + EN0_RCNTHI); ! 594: outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO); ! 595: outb_p(ring_offset >> 8, nic_base + EN0_RSARHI); ! 596: outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); ! 597: if (ei_status.word16) { ! 598: insw(NE_BASE + NE_DATAPORT,buf,count>>1); ! 599: if (count & 0x01) { ! 600: buf[count-1] = inb(NE_BASE + NE_DATAPORT); ! 601: #ifdef NE_SANITY_CHECK ! 602: xfer_count++; ! 603: #endif ! 604: } ! 605: } else { ! 606: insb(NE_BASE + NE_DATAPORT, buf, count); ! 607: } ! 608: ! 609: #ifdef NE_SANITY_CHECK ! 610: /* This was for the ALPHA version only, but enough people have ! 611: been encountering problems so it is still here. If you see ! 612: this message you either 1) have a slightly incompatible clone ! 613: or 2) have noise/speed problems with your bus. */ ! 614: if (ei_debug > 1) { /* DMA termination address check... */ ! 615: int addr, tries = 20; ! 616: do { ! 617: /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here ! 618: -- it's broken for Rx on some cards! */ ! 619: int high = inb_p(nic_base + EN0_RSARHI); ! 620: int low = inb_p(nic_base + EN0_RSARLO); ! 621: addr = (high << 8) + low; ! 622: if (((ring_offset + xfer_count) & 0xff) == low) ! 623: break; ! 624: } while (--tries > 0); ! 625: if (tries <= 0) ! 626: printk("%s: RX transfer address mismatch," ! 627: "%#4.4x (expected) vs. %#4.4x (actual).\n", ! 628: dev->name, ring_offset + xfer_count, addr); ! 629: } ! 630: #endif ! 631: outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ ! 632: ei_status.dmaing &= ~0x01; ! 633: } ! 634: ! 635: static void ! 636: ne_block_output(struct device *dev, int count, ! 637: const unsigned char *buf, const int start_page) ! 638: { ! 639: int nic_base = NE_BASE; ! 640: unsigned long dma_start; ! 641: #ifdef NE_SANITY_CHECK ! 642: int retries = 0; ! 643: #endif ! 644: ! 645: /* Round the count up for word writes. Do we need to do this? ! 646: What effect will an odd byte count have on the 8390? ! 647: I should check someday. */ ! 648: if (ei_status.word16 && (count & 0x01)) ! 649: count++; ! 650: ! 651: /* This *shouldn't* happen. If it does, it's the last thing you'll see */ ! 652: if (ei_status.dmaing) { ! 653: printk("%s: DMAing conflict in ne_block_output." ! 654: "[DMAstat:%d][irqlock:%d][intr:%d]\n", ! 655: dev->name, ei_status.dmaing, ei_status.irqlock, ! 656: dev->interrupt); ! 657: return; ! 658: } ! 659: ei_status.dmaing |= 0x01; ! 660: /* We should already be in page 0, but to be safe... */ ! 661: outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); ! 662: ! 663: #ifdef NE_SANITY_CHECK ! 664: retry: ! 665: #endif ! 666: ! 667: #ifdef NE8390_RW_BUGFIX ! 668: /* Handle the read-before-write bug the same way as the ! 669: Crynwr packet driver -- the NatSemi method doesn't work. ! 670: Actually this doesn't always work either, but if you have ! 671: problems with your NEx000 this is better than nothing! */ ! 672: outb_p(0x42, nic_base + EN0_RCNTLO); ! 673: outb_p(0x00, nic_base + EN0_RCNTHI); ! 674: outb_p(0x42, nic_base + EN0_RSARLO); ! 675: outb_p(0x00, nic_base + EN0_RSARHI); ! 676: outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); ! 677: /* Make certain that the dummy read has occurred. */ ! 678: SLOW_DOWN_IO; ! 679: SLOW_DOWN_IO; ! 680: SLOW_DOWN_IO; ! 681: #endif ! 682: ! 683: outb_p(ENISR_RDC, nic_base + EN0_ISR); ! 684: ! 685: /* Now the normal output. */ ! 686: outb_p(count & 0xff, nic_base + EN0_RCNTLO); ! 687: outb_p(count >> 8, nic_base + EN0_RCNTHI); ! 688: outb_p(0x00, nic_base + EN0_RSARLO); ! 689: outb_p(start_page, nic_base + EN0_RSARHI); ! 690: ! 691: outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD); ! 692: if (ei_status.word16) { ! 693: outsw(NE_BASE + NE_DATAPORT, buf, count>>1); ! 694: } else { ! 695: outsb(NE_BASE + NE_DATAPORT, buf, count); ! 696: } ! 697: ! 698: dma_start = jiffies; ! 699: ! 700: #ifdef NE_SANITY_CHECK ! 701: /* This was for the ALPHA version only, but enough people have ! 702: been encountering problems so it is still here. */ ! 703: if (ei_debug > 1) { /* DMA termination address check... */ ! 704: int addr, tries = 20; ! 705: do { ! 706: int high = inb_p(nic_base + EN0_RSARHI); ! 707: int low = inb_p(nic_base + EN0_RSARLO); ! 708: addr = (high << 8) + low; ! 709: if ((start_page << 8) + count == addr) ! 710: break; ! 711: } while (--tries > 0); ! 712: if (tries <= 0) { ! 713: printk("%s: Tx packet transfer address mismatch," ! 714: "%#4.4x (expected) vs. %#4.4x (actual).\n", ! 715: dev->name, (start_page << 8) + count, addr); ! 716: if (retries++ == 0) ! 717: goto retry; ! 718: } ! 719: } ! 720: #endif ! 721: ! 722: while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0) ! 723: if (jiffies - dma_start > 2*HZ/100) { /* 20ms */ ! 724: printk("%s: timeout waiting for Tx RDC.\n", dev->name); ! 725: ne_reset_8390(dev); ! 726: NS8390_init(dev,1); ! 727: break; ! 728: } ! 729: ! 730: outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ ! 731: ei_status.dmaing &= ~0x01; ! 732: return; ! 733: } ! 734: ! 735: ! 736: #ifdef MODULE ! 737: #define MAX_NE_CARDS 4 /* Max number of NE cards per module */ ! 738: #define NAMELEN 8 /* # of chars for storing dev->name */ ! 739: static char namelist[NAMELEN * MAX_NE_CARDS] = { 0, }; ! 740: static struct device dev_ne[MAX_NE_CARDS] = { ! 741: { ! 742: NULL, /* assign a chunk of namelist[] below */ ! 743: 0, 0, 0, 0, ! 744: 0, 0, ! 745: 0, 0, 0, NULL, NULL ! 746: }, ! 747: }; ! 748: ! 749: static int io[MAX_NE_CARDS] = { 0, }; ! 750: static int irq[MAX_NE_CARDS] = { 0, }; ! 751: static int bad[MAX_NE_CARDS] = { 0, }; ! 752: ! 753: /* This is set up so that no autoprobe takes place. We can't guarantee ! 754: that the ne2k probe is the last 8390 based probe to take place (as it ! 755: is at boot) and so the probe will get confused by any other 8390 cards. ! 756: ISA device autoprobes on a running machine are not recommended anyway. */ ! 757: ! 758: int ! 759: init_module(void) ! 760: { ! 761: int this_dev, found = 0; ! 762: ! 763: for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { ! 764: struct device *dev = &dev_ne[this_dev]; ! 765: dev->name = namelist+(NAMELEN*this_dev); ! 766: dev->irq = irq[this_dev]; ! 767: dev->base_addr = io[this_dev]; ! 768: dev->init = ne_probe; ! 769: dev->mem_end = bad[this_dev]; ! 770: if (register_netdev(dev) == 0) { ! 771: found++; ! 772: continue; ! 773: } ! 774: if (found != 0) /* Got at least one. */ ! 775: return 0; ! 776: if (io[this_dev] != 0) ! 777: printk(KERN_WARNING "ne.c: No NE*000 card found at i/o = %#x\n", io[this_dev]); ! 778: else ! 779: printk(KERN_NOTICE "ne.c: No PCI cards found. Use \"io=0xNNN\" value(s) for ISA cards.\n"); ! 780: return -ENXIO; ! 781: } ! 782: ! 783: return 0; ! 784: } ! 785: ! 786: void ! 787: cleanup_module(void) ! 788: { ! 789: int this_dev; ! 790: ! 791: for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { ! 792: struct device *dev = &dev_ne[this_dev]; ! 793: if (dev->priv != NULL) { ! 794: kfree(dev->priv); ! 795: dev->priv = NULL; ! 796: free_irq(dev->irq, dev); ! 797: irq2dev_map[dev->irq] = NULL; ! 798: release_region(dev->base_addr, NE_IO_EXTENT); ! 799: unregister_netdev(dev); ! 800: } ! 801: } ! 802: } ! 803: #endif /* MODULE */ ! 804: ! 805: /* ! 806: * Local variables: ! 807: * compile-command: "gcc -DKERNEL -Wall -O6 -fomit-frame-pointer -I/usr/src/linux/net/tcp -c ne.c" ! 808: * version-control: t ! 809: * kept-new-versions: 5 ! 810: * End: ! 811: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.