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 General Public License, incorporated herein by reference. 10 11 The author may be reached as becker@scyld.com, or C/O 12 Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403 13 14 This driver should work with many programmed-I/O 8390-based ethernet 15 boards. Currently it supports the NE1000, NE2000, many clones, 16 and some Cabletron products. 17 18 Changelog: 19 20 Paul Gortmaker : use ENISR_RDC to monitor Tx PIO uploads, made 21 sanity checks and bad clone support optional. 22 Paul Gortmaker : new reset code, reset card after probe at boot. 23 Paul Gortmaker : multiple card support for module users. 24 Paul Gortmaker : Support for PCI ne2k clones, similar to lance.c 25 Paul Gortmaker : Allow users with bad cards to avoid full probe. 26 Paul Gortmaker : PCI probe changes, more PCI cards supported. 27 rjohnson@analogic.com : Changed init order so an interrupt will only 28 occur after memory is allocated for dev->priv. Deallocated memory 29 last in cleanup_modue() 30 Richard Guenther : Added support for ISAPnP cards 31 Paul Gortmaker : Discontinued PCI support - use ne2k-pci.c instead. 32 Hayato Fujiwara : Add m32r support. 33 34 */ 35 36 /* Routines for the NatSemi-based designs (NE[12]000). */ 37 38 static const char version1[] = 39 "ne.c:v1.10 9/23/94 Donald Becker (becker@scyld.com)\n"; 40 static const char version2[] = 41 "Last modified Nov 1, 2000 by Paul Gortmaker\n"; 42 43 44 #include <linux/module.h> 45 #include <linux/kernel.h> 46 #include <linux/errno.h> 47 #include <linux/isapnp.h> 48 #include <linux/init.h> 49 #include <linux/interrupt.h> 50 #include <linux/delay.h> 51 #include <linux/netdevice.h> 52 #include <linux/etherdevice.h> 53 #include <linux/jiffies.h> 54 #include <linux/platform_device.h> 55 #include <net/Space.h> 56 57 #include <asm/io.h> 58 59 #include "8390.h" 60 61 #define DRV_NAME "ne" 62 63 /* Some defines that people can play with if so inclined. */ 64 65 /* Do we support clones that don't adhere to 14,15 of the SAprom ? */ 66 #define SUPPORT_NE_BAD_CLONES 67 /* 0xbad = bad sig or no reset ack */ 68 #define BAD 0xbad 69 70 #define MAX_NE_CARDS 4 /* Max number of NE cards per module */ 71 static struct platform_device *pdev_ne[MAX_NE_CARDS]; 72 static int io[MAX_NE_CARDS]; 73 static int irq[MAX_NE_CARDS]; 74 static int bad[MAX_NE_CARDS]; 75 static u32 ne_msg_enable; 76 77 #ifdef MODULE 78 module_param_hw_array(io, int, ioport, NULL, 0); 79 module_param_hw_array(irq, int, irq, NULL, 0); 80 module_param_array(bad, int, NULL, 0); 81 module_param_named(msg_enable, ne_msg_enable, uint, 0444); 82 MODULE_PARM_DESC(io, "I/O base address(es),required"); 83 MODULE_PARM_DESC(irq, "IRQ number(s)"); 84 MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures"); 85 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)"); 86 MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver"); 87 MODULE_LICENSE("GPL"); 88 #endif /* MODULE */ 89 90 /* Do we perform extra sanity checks on stuff ? */ 91 /* #define NE_SANITY_CHECK */ 92 93 /* Do we implement the read before write bugfix ? */ 94 /* #define NE_RW_BUGFIX */ 95 96 /* Do we have a non std. amount of memory? (in units of 256 byte pages) */ 97 /* #define PACKETBUF_MEMSIZE 0x40 */ 98 99 /* This is set up so that no ISA autoprobe takes place. We can't guarantee 100 that the ne2k probe is the last 8390 based probe to take place (as it 101 is at boot) and so the probe will get confused by any other 8390 cards. 102 ISA device autoprobes on a running machine are not recommended anyway. */ 103 #if !defined(MODULE) && defined(CONFIG_ISA) 104 /* Do we need a portlist for the ISA auto-probe ? */ 105 #define NEEDS_PORTLIST 106 #endif 107 108 /* A zero-terminated list of I/O addresses to be probed at boot. */ 109 #ifdef NEEDS_PORTLIST 110 static unsigned int netcard_portlist[] __initdata = { 111 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0 112 }; 113 #endif 114 115 static struct isapnp_device_id isapnp_clone_list[] __initdata = { 116 { ISAPNP_CARD_ID('A','X','E',0x2011), 117 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011), 118 (long) "NetGear EA201" }, 119 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 120 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216), 121 (long) "NN NE2000" }, 122 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 123 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6), 124 (long) "Generic PNP" }, 125 { } /* terminate list */ 126 }; 127 128 MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list); 129 130 #ifdef SUPPORT_NE_BAD_CLONES 131 /* A list of bad clones that we none-the-less recognize. */ 132 static struct { const char *name8, *name16; unsigned char SAprefix[4];} 133 bad_clone_list[] __initdata = { 134 {"DE100", "DE200", {0x00, 0xDE, 0x01,}}, 135 {"DE120", "DE220", {0x00, 0x80, 0xc8,}}, 136 {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */ 137 {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}}, 138 {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */ 139 {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */ 140 {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */ 141 {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */ 142 {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */ 143 {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */ 144 {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */ 145 {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */ 146 {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */ 147 #ifdef CONFIG_MACH_TX49XX 148 {"RBHMA4X00-RTL8019", "RBHMA4X00-RTL8019", {0x00, 0x60, 0x0a}}, /* Toshiba built-in */ 149 #endif 150 {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */ 151 {NULL,} 152 }; 153 #endif 154 155 /* ---- No user-serviceable parts below ---- */ 156 157 #define NE_BASE (dev->base_addr) 158 #define NE_CMD 0x00 159 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */ 160 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */ 161 #define NE_IO_EXTENT 0x20 162 163 #define NE1SM_START_PG 0x20 /* First page of TX buffer */ 164 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */ 165 #define NESM_START_PG 0x40 /* First page of TX buffer */ 166 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ 167 168 #if defined(CONFIG_MACH_TX49XX) 169 # define DCR_VAL 0x48 /* 8-bit mode */ 170 #elif defined(CONFIG_ATARI) /* 8-bit mode on Atari, normal on Q40 */ 171 # define DCR_VAL (MACH_IS_ATARI ? 0x48 : 0x49) 172 #else 173 # define DCR_VAL 0x49 174 #endif 175 176 static int ne_probe1(struct net_device *dev, unsigned long ioaddr); 177 static int ne_probe_isapnp(struct net_device *dev); 178 179 static void ne_reset_8390(struct net_device *dev); 180 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 181 int ring_page); 182 static void ne_block_input(struct net_device *dev, int count, 183 struct sk_buff *skb, int ring_offset); 184 static void ne_block_output(struct net_device *dev, const int count, 185 const unsigned char *buf, const int start_page); 186 187 188 /* Probe for various non-shared-memory ethercards. 189 190 NEx000-clone boards have a Station Address PROM (SAPROM) in the packet 191 buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of 192 the SAPROM, while other supposed NE2000 clones must be detected by their 193 SA prefix. 194 195 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide 196 mode results in doubled values, which can be detected and compensated for. 197 198 The probe is also responsible for initializing the card and filling 199 in the 'dev' and 'ei_status' structures. 200 201 We use the minimum memory size for some ethercard product lines, iff we can't 202 distinguish models. You can increase the packet buffer size by setting 203 PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are: 204 E1010 starts at 0x100 and ends at 0x2000. 205 E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory") 206 E2010 starts at 0x100 and ends at 0x4000. 207 E2010-x starts at 0x100 and ends at 0xffff. */ 208 209 static int __init do_ne_probe(struct net_device *dev) 210 { 211 unsigned long base_addr = dev->base_addr; 212 #ifdef NEEDS_PORTLIST 213 int orig_irq = dev->irq; 214 #endif 215 216 /* First check any supplied i/o locations. User knows best. <cough> */ 217 if (base_addr > 0x1ff) { /* Check a single specified location. */ 218 int ret = ne_probe1(dev, base_addr); 219 if (ret) 220 netdev_warn(dev, "ne.c: No NE*000 card found at " 221 "i/o = %#lx\n", base_addr); 222 return ret; 223 } 224 else if (base_addr != 0) /* Don't probe at all. */ 225 return -ENXIO; 226 227 /* Then look for any installed ISAPnP clones */ 228 if (isapnp_present() && (ne_probe_isapnp(dev) == 0)) 229 return 0; 230 231 #ifdef NEEDS_PORTLIST 232 /* Last resort. The semi-risky ISA auto-probe. */ 233 for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) { 234 int ioaddr = netcard_portlist[base_addr]; 235 dev->irq = orig_irq; 236 if (ne_probe1(dev, ioaddr) == 0) 237 return 0; 238 } 239 #endif 240 241 return -ENODEV; 242 } 243 244 static int __init ne_probe_isapnp(struct net_device *dev) 245 { 246 int i; 247 248 for (i = 0; isapnp_clone_list[i].vendor != 0; i++) { 249 struct pnp_dev *idev = NULL; 250 251 while ((idev = pnp_find_dev(NULL, 252 isapnp_clone_list[i].vendor, 253 isapnp_clone_list[i].function, 254 idev))) { 255 /* Avoid already found cards from previous calls */ 256 if (pnp_device_attach(idev) < 0) 257 continue; 258 if (pnp_activate_dev(idev) < 0) { 259 pnp_device_detach(idev); 260 continue; 261 } 262 /* if no io and irq, search for next */ 263 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) { 264 pnp_device_detach(idev); 265 continue; 266 } 267 /* found it */ 268 dev->base_addr = pnp_port_start(idev, 0); 269 dev->irq = pnp_irq(idev, 0); 270 netdev_info(dev, 271 "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n", 272 (char *) isapnp_clone_list[i].driver_data, 273 dev->base_addr, dev->irq); 274 if (ne_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */ 275 netdev_err(dev, 276 "ne.c: Probe of ISAPnP card at %#lx failed.\n", 277 dev->base_addr); 278 pnp_device_detach(idev); 279 return -ENXIO; 280 } 281 ei_status.priv = (unsigned long)idev; 282 break; 283 } 284 if (!idev) 285 continue; 286 return 0; 287 } 288 289 return -ENODEV; 290 } 291 292 static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr) 293 { 294 int i; 295 unsigned char SA_prom[32]; 296 int wordlength = 2; 297 const char *name = NULL; 298 int start_page, stop_page; 299 int neX000, ctron, copam, bad_card; 300 int reg0, ret; 301 static unsigned version_printed; 302 struct ei_device *ei_local = netdev_priv(dev); 303 304 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME)) 305 return -EBUSY; 306 307 reg0 = inb_p(ioaddr); 308 if (reg0 == 0xFF) { 309 ret = -ENODEV; 310 goto err_out; 311 } 312 313 /* Do a preliminary verification that we have a 8390. */ 314 { 315 int regd; 316 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD); 317 regd = inb_p(ioaddr + 0x0d); 318 outb_p(0xff, ioaddr + 0x0d); 319 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD); 320 inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */ 321 if (inb_p(ioaddr + EN0_COUNTER0) != 0) { 322 outb_p(reg0, ioaddr); 323 outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */ 324 ret = -ENODEV; 325 goto err_out; 326 } 327 } 328 329 if ((ne_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0)) 330 netdev_info(dev, "%s%s", version1, version2); 331 332 netdev_info(dev, "NE*000 ethercard probe at %#3lx:", ioaddr); 333 334 /* A user with a poor card that fails to ack the reset, or that 335 does not have a valid 0x57,0x57 signature can still use this 336 without having to recompile. Specifying an i/o address along 337 with an otherwise unused dev->mem_end value of "0xBAD" will 338 cause the driver to skip these parts of the probe. */ 339 340 bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD)); 341 342 /* Reset card. Who knows what dain-bramaged state it was left in. */ 343 344 { 345 unsigned long reset_start_time = jiffies; 346 347 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ 348 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET); 349 350 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0) 351 if (time_after(jiffies, reset_start_time + 2*HZ/100)) { 352 if (bad_card) { 353 pr_cont(" (warning: no reset ack)"); 354 break; 355 } else { 356 pr_cont(" not found (no reset ack).\n"); 357 ret = -ENODEV; 358 goto err_out; 359 } 360 } 361 362 outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */ 363 } 364 365 /* Read the 16 bytes of station address PROM. 366 We must first initialize registers, similar to NS8390p_init(eifdev, 0). 367 We can't reliably read the SAPROM address without this. 368 (I learned the hard way!). */ 369 { 370 struct {unsigned char value, offset; } program_seq[] = 371 { 372 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/ 373 {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */ 374 {0x00, EN0_RCNTLO}, /* Clear the count regs. */ 375 {0x00, EN0_RCNTHI}, 376 {0x00, EN0_IMR}, /* Mask completion irq. */ 377 {0xFF, EN0_ISR}, 378 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */ 379 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */ 380 {32, EN0_RCNTLO}, 381 {0x00, EN0_RCNTHI}, 382 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */ 383 {0x00, EN0_RSARHI}, 384 {E8390_RREAD+E8390_START, E8390_CMD}, 385 }; 386 387 for (i = 0; i < ARRAY_SIZE(program_seq); i++) 388 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset); 389 390 } 391 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) { 392 SA_prom[i] = inb(ioaddr + NE_DATAPORT); 393 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT); 394 if (SA_prom[i] != SA_prom[i+1]) 395 wordlength = 1; 396 } 397 398 if (wordlength == 2) 399 { 400 for (i = 0; i < 16; i++) 401 SA_prom[i] = SA_prom[i+i]; 402 /* We must set the 8390 for word mode. */ 403 outb_p(DCR_VAL, ioaddr + EN0_DCFG); 404 start_page = NESM_START_PG; 405 406 /* 407 * Realtek RTL8019AS datasheet says that the PSTOP register 408 * shouldn't exceed 0x60 in 8-bit mode. 409 * This chip can be identified by reading the signature from 410 * the remote byte count registers (otherwise write-only)... 411 */ 412 if ((DCR_VAL & 0x01) == 0 && /* 8-bit mode */ 413 inb(ioaddr + EN0_RCNTLO) == 0x50 && 414 inb(ioaddr + EN0_RCNTHI) == 0x70) 415 stop_page = 0x60; 416 else 417 stop_page = NESM_STOP_PG; 418 } else { 419 start_page = NE1SM_START_PG; 420 stop_page = NE1SM_STOP_PG; 421 } 422 423 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57); 424 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d); 425 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00); 426 427 /* Set up the rest of the parameters. */ 428 if (neX000 || bad_card || copam) { 429 name = (wordlength == 2) ? "NE2000" : "NE1000"; 430 } 431 else if (ctron) 432 { 433 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16"; 434 start_page = 0x01; 435 stop_page = (wordlength == 2) ? 0x40 : 0x20; 436 } 437 else 438 { 439 #ifdef SUPPORT_NE_BAD_CLONES 440 /* Ack! Well, there might be a *bad* NE*000 clone there. 441 Check for total bogus addresses. */ 442 for (i = 0; bad_clone_list[i].name8; i++) 443 { 444 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] && 445 SA_prom[1] == bad_clone_list[i].SAprefix[1] && 446 SA_prom[2] == bad_clone_list[i].SAprefix[2]) 447 { 448 if (wordlength == 2) 449 { 450 name = bad_clone_list[i].name16; 451 } else { 452 name = bad_clone_list[i].name8; 453 } 454 break; 455 } 456 } 457 if (bad_clone_list[i].name8 == NULL) 458 { 459 pr_cont(" not found (invalid signature %2.2x %2.2x).\n", 460 SA_prom[14], SA_prom[15]); 461 ret = -ENXIO; 462 goto err_out; 463 } 464 #else 465 pr_cont(" not found.\n"); 466 ret = -ENXIO; 467 goto err_out; 468 #endif 469 } 470 471 if (dev->irq < 2) 472 { 473 unsigned long cookie = probe_irq_on(); 474 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */ 475 outb_p(0x00, ioaddr + EN0_RCNTLO); 476 outb_p(0x00, ioaddr + EN0_RCNTHI); 477 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */ 478 mdelay(10); /* wait 10ms for interrupt to propagate */ 479 outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */ 480 dev->irq = probe_irq_off(cookie); 481 if (ne_msg_enable & NETIF_MSG_PROBE) 482 pr_cont(" autoirq is %d", dev->irq); 483 } else if (dev->irq == 2) 484 /* Fixup for users that don't know that IRQ 2 is really IRQ 9, 485 or don't know which one to set. */ 486 dev->irq = 9; 487 488 if (! dev->irq) { 489 pr_cont(" failed to detect IRQ line.\n"); 490 ret = -EAGAIN; 491 goto err_out; 492 } 493 494 /* Snarf the interrupt now. There's no point in waiting since we cannot 495 share and the board will usually be enabled. */ 496 ret = request_irq(dev->irq, eip_interrupt, 0, name, dev); 497 if (ret) { 498 pr_cont(" unable to get IRQ %d (errno=%d).\n", dev->irq, ret); 499 goto err_out; 500 } 501 502 dev->base_addr = ioaddr; 503 504 eth_hw_addr_set(dev, SA_prom); 505 506 pr_cont("%pM\n", dev->dev_addr); 507 508 ei_status.name = name; 509 ei_status.tx_start_page = start_page; 510 ei_status.stop_page = stop_page; 511 512 /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */ 513 ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01)); 514 515 ei_status.rx_start_page = start_page + TX_PAGES; 516 #ifdef PACKETBUF_MEMSIZE 517 /* Allow the packet buffer size to be overridden by know-it-alls. */ 518 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE; 519 #endif 520 521 ei_status.reset_8390 = &ne_reset_8390; 522 ei_status.block_input = &ne_block_input; 523 ei_status.block_output = &ne_block_output; 524 ei_status.get_8390_hdr = &ne_get_8390_hdr; 525 ei_status.priv = 0; 526 527 dev->netdev_ops = &eip_netdev_ops; 528 NS8390p_init(dev, 0); 529 530 ei_local->msg_enable = ne_msg_enable; 531 ret = register_netdev(dev); 532 if (ret) 533 goto out_irq; 534 netdev_info(dev, "%s found at %#lx, using IRQ %d.\n", 535 name, ioaddr, dev->irq); 536 return 0; 537 538 out_irq: 539 free_irq(dev->irq, dev); 540 err_out: 541 release_region(ioaddr, NE_IO_EXTENT); 542 return ret; 543 } 544 545 /* Hard reset the card. This used to pause for the same period that a 546 8390 reset command required, but that shouldn't be necessary. */ 547 548 static void ne_reset_8390(struct net_device *dev) 549 { 550 unsigned long reset_start_time = jiffies; 551 struct ei_device *ei_local = netdev_priv(dev); 552 553 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n", jiffies); 554 555 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ 556 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); 557 558 ei_status.txing = 0; 559 ei_status.dmaing = 0; 560 561 /* This check _should_not_ be necessary, omit eventually. */ 562 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0) 563 if (time_after(jiffies, reset_start_time + 2*HZ/100)) { 564 netdev_err(dev, "ne_reset_8390() did not complete.\n"); 565 break; 566 } 567 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */ 568 } 569 570 /* Grab the 8390 specific header. Similar to the block_input routine, but 571 we don't need to be concerned with ring wrap as the header will be at 572 the start of a page, so we optimize accordingly. */ 573 574 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 575 { 576 int nic_base = dev->base_addr; 577 578 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 579 580 if (ei_status.dmaing) 581 { 582 netdev_err(dev, "DMAing conflict in ne_get_8390_hdr " 583 "[DMAstat:%d][irqlock:%d].\n", 584 ei_status.dmaing, ei_status.irqlock); 585 return; 586 } 587 588 ei_status.dmaing |= 0x01; 589 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); 590 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO); 591 outb_p(0, nic_base + EN0_RCNTHI); 592 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */ 593 outb_p(ring_page, nic_base + EN0_RSARHI); 594 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 595 596 if (ei_status.word16) 597 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1); 598 else 599 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)); 600 601 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ 602 ei_status.dmaing &= ~0x01; 603 604 le16_to_cpus(&hdr->count); 605 } 606 607 /* Block input and output, similar to the Crynwr packet driver. If you 608 are porting to a new ethercard, look at the packet driver source for hints. 609 The NEx000 doesn't share the on-board packet memory -- you have to put 610 the packet out through the "remote DMA" dataport using outb. */ 611 612 static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 613 { 614 #ifdef NE_SANITY_CHECK 615 int xfer_count = count; 616 struct ei_device *ei_local = netdev_priv(dev); 617 #endif 618 int nic_base = dev->base_addr; 619 char *buf = skb->data; 620 621 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 622 if (ei_status.dmaing) 623 { 624 netdev_err(dev, "DMAing conflict in ne_block_input " 625 "[DMAstat:%d][irqlock:%d].\n", 626 ei_status.dmaing, ei_status.irqlock); 627 return; 628 } 629 ei_status.dmaing |= 0x01; 630 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); 631 outb_p(count & 0xff, nic_base + EN0_RCNTLO); 632 outb_p(count >> 8, nic_base + EN0_RCNTHI); 633 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO); 634 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI); 635 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 636 if (ei_status.word16) 637 { 638 insw(NE_BASE + NE_DATAPORT,buf,count>>1); 639 if (count & 0x01) 640 { 641 buf[count-1] = inb(NE_BASE + NE_DATAPORT); 642 #ifdef NE_SANITY_CHECK 643 xfer_count++; 644 #endif 645 } 646 } else { 647 insb(NE_BASE + NE_DATAPORT, buf, count); 648 } 649 650 #ifdef NE_SANITY_CHECK 651 /* This was for the ALPHA version only, but enough people have 652 been encountering problems so it is still here. If you see 653 this message you either 1) have a slightly incompatible clone 654 or 2) have noise/speed problems with your bus. */ 655 656 if (netif_msg_rx_status(ei_local)) 657 { 658 /* DMA termination address check... */ 659 int addr, tries = 20; 660 do { 661 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here 662 -- it's broken for Rx on some cards! */ 663 int high = inb_p(nic_base + EN0_RSARHI); 664 int low = inb_p(nic_base + EN0_RSARLO); 665 addr = (high << 8) + low; 666 if (((ring_offset + xfer_count) & 0xff) == low) 667 break; 668 } while (--tries > 0); 669 if (tries <= 0) 670 netdev_warn(dev, "RX transfer address mismatch," 671 "%#4.4x (expected) vs. %#4.4x (actual).\n", 672 ring_offset + xfer_count, addr); 673 } 674 #endif 675 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ 676 ei_status.dmaing &= ~0x01; 677 } 678 679 static void ne_block_output(struct net_device *dev, int count, 680 const unsigned char *buf, const int start_page) 681 { 682 int nic_base = NE_BASE; 683 unsigned long dma_start; 684 #ifdef NE_SANITY_CHECK 685 int retries = 0; 686 struct ei_device *ei_local = netdev_priv(dev); 687 #endif 688 689 /* Round the count up for word writes. Do we need to do this? 690 What effect will an odd byte count have on the 8390? 691 I should check someday. */ 692 693 if (ei_status.word16 && (count & 0x01)) 694 count++; 695 696 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 697 if (ei_status.dmaing) 698 { 699 netdev_err(dev, "DMAing conflict in ne_block_output." 700 "[DMAstat:%d][irqlock:%d]\n", 701 ei_status.dmaing, ei_status.irqlock); 702 return; 703 } 704 ei_status.dmaing |= 0x01; 705 /* We should already be in page 0, but to be safe... */ 706 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); 707 708 #ifdef NE_SANITY_CHECK 709 retry: 710 #endif 711 712 #ifdef NE_RW_BUGFIX 713 /* Handle the read-before-write bug the same way as the 714 Crynwr packet driver -- the NatSemi method doesn't work. 715 Actually this doesn't always work either, but if you have 716 problems with your NEx000 this is better than nothing! */ 717 718 outb_p(0x42, nic_base + EN0_RCNTLO); 719 outb_p(0x00, nic_base + EN0_RCNTHI); 720 outb_p(0x42, nic_base + EN0_RSARLO); 721 outb_p(0x00, nic_base + EN0_RSARHI); 722 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 723 /* Make certain that the dummy read has occurred. */ 724 udelay(6); 725 #endif 726 727 outb_p(ENISR_RDC, nic_base + EN0_ISR); 728 729 /* Now the normal output. */ 730 outb_p(count & 0xff, nic_base + EN0_RCNTLO); 731 outb_p(count >> 8, nic_base + EN0_RCNTHI); 732 outb_p(0x00, nic_base + EN0_RSARLO); 733 outb_p(start_page, nic_base + EN0_RSARHI); 734 735 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD); 736 if (ei_status.word16) { 737 outsw(NE_BASE + NE_DATAPORT, buf, count>>1); 738 } else { 739 outsb(NE_BASE + NE_DATAPORT, buf, count); 740 } 741 742 dma_start = jiffies; 743 744 #ifdef NE_SANITY_CHECK 745 /* This was for the ALPHA version only, but enough people have 746 been encountering problems so it is still here. */ 747 748 if (netif_msg_tx_queued(ei_local)) 749 { 750 /* DMA termination address check... */ 751 int addr, tries = 20; 752 do { 753 int high = inb_p(nic_base + EN0_RSARHI); 754 int low = inb_p(nic_base + EN0_RSARLO); 755 addr = (high << 8) + low; 756 if ((start_page << 8) + count == addr) 757 break; 758 } while (--tries > 0); 759 760 if (tries <= 0) 761 { 762 netdev_warn(dev, "Tx packet transfer address mismatch," 763 "%#4.4x (expected) vs. %#4.4x (actual).\n", 764 (start_page << 8) + count, addr); 765 if (retries++ == 0) 766 goto retry; 767 } 768 } 769 #endif 770 771 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0) 772 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */ 773 netdev_warn(dev, "timeout waiting for Tx RDC.\n"); 774 ne_reset_8390(dev); 775 NS8390p_init(dev, 1); 776 break; 777 } 778 779 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ 780 ei_status.dmaing &= ~0x01; 781 } 782 783 static int __init ne_drv_probe(struct platform_device *pdev) 784 { 785 struct net_device *dev; 786 int err, this_dev = pdev->id; 787 struct resource *res; 788 789 dev = alloc_eip_netdev(); 790 if (!dev) 791 return -ENOMEM; 792 793 /* ne.c doesn't populate resources in platform_device, but 794 * rbtx4927_ne_init and rbtx4938_ne_init do register devices 795 * with resources. 796 */ 797 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 798 if (res) { 799 dev->base_addr = res->start; 800 dev->irq = platform_get_irq(pdev, 0); 801 } else { 802 if (this_dev < 0 || this_dev >= MAX_NE_CARDS) { 803 free_netdev(dev); 804 return -EINVAL; 805 } 806 dev->base_addr = io[this_dev]; 807 dev->irq = irq[this_dev]; 808 dev->mem_end = bad[this_dev]; 809 } 810 SET_NETDEV_DEV(dev, &pdev->dev); 811 err = do_ne_probe(dev); 812 if (err) { 813 free_netdev(dev); 814 return err; 815 } 816 platform_set_drvdata(pdev, dev); 817 818 /* Update with any values found by probing, don't update if 819 * resources were specified. 820 */ 821 if (!res) { 822 io[this_dev] = dev->base_addr; 823 irq[this_dev] = dev->irq; 824 } 825 return 0; 826 } 827 828 static int ne_drv_remove(struct platform_device *pdev) 829 { 830 struct net_device *dev = platform_get_drvdata(pdev); 831 832 if (dev) { 833 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; 834 netif_device_detach(dev); 835 unregister_netdev(dev); 836 if (idev) 837 pnp_device_detach(idev); 838 /* Careful ne_drv_remove can be called twice, once from 839 * the platform_driver.remove and again when the 840 * platform_device is being removed. 841 */ 842 ei_status.priv = 0; 843 free_irq(dev->irq, dev); 844 release_region(dev->base_addr, NE_IO_EXTENT); 845 free_netdev(dev); 846 } 847 return 0; 848 } 849 850 /* Remove unused devices or all if true. */ 851 static void ne_loop_rm_unreg(int all) 852 { 853 int this_dev; 854 struct platform_device *pdev; 855 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { 856 pdev = pdev_ne[this_dev]; 857 /* No network device == unused */ 858 if (pdev && (!platform_get_drvdata(pdev) || all)) { 859 ne_drv_remove(pdev); 860 platform_device_unregister(pdev); 861 pdev_ne[this_dev] = NULL; 862 } 863 } 864 } 865 866 #ifdef CONFIG_PM 867 static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state) 868 { 869 struct net_device *dev = platform_get_drvdata(pdev); 870 871 if (netif_running(dev)) { 872 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; 873 netif_device_detach(dev); 874 if (idev) 875 pnp_stop_dev(idev); 876 } 877 return 0; 878 } 879 880 static int ne_drv_resume(struct platform_device *pdev) 881 { 882 struct net_device *dev = platform_get_drvdata(pdev); 883 884 if (netif_running(dev)) { 885 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; 886 if (idev) 887 pnp_start_dev(idev); 888 ne_reset_8390(dev); 889 NS8390p_init(dev, 1); 890 netif_device_attach(dev); 891 } 892 return 0; 893 } 894 #else 895 #define ne_drv_suspend NULL 896 #define ne_drv_resume NULL 897 #endif 898 899 static struct platform_driver ne_driver = { 900 .remove = ne_drv_remove, 901 .suspend = ne_drv_suspend, 902 .resume = ne_drv_resume, 903 .driver = { 904 .name = DRV_NAME, 905 }, 906 }; 907 908 static void __init ne_add_devices(void) 909 { 910 int this_dev; 911 struct platform_device *pdev; 912 913 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { 914 if (pdev_ne[this_dev]) 915 continue; 916 pdev = platform_device_register_simple( 917 DRV_NAME, this_dev, NULL, 0); 918 if (IS_ERR(pdev)) 919 continue; 920 pdev_ne[this_dev] = pdev; 921 } 922 } 923 924 static int __init ne_init(void) 925 { 926 int retval; 927 928 if (IS_MODULE(CONFIG_NE2000)) 929 ne_add_devices(); 930 931 retval = platform_driver_probe(&ne_driver, ne_drv_probe); 932 933 if (IS_MODULE(CONFIG_NE2000) && retval) { 934 if (io[0] == 0) 935 pr_notice("ne.c: You must supply \"io=0xNNN\"" 936 " value(s) for ISA cards.\n"); 937 ne_loop_rm_unreg(1); 938 return retval; 939 } 940 941 /* Unregister unused platform_devices. */ 942 ne_loop_rm_unreg(0); 943 return retval; 944 } 945 module_init(ne_init); 946 947 #if !defined(MODULE) && defined(CONFIG_NETDEV_LEGACY_INIT) 948 struct net_device * __init ne_probe(int unit) 949 { 950 int this_dev; 951 struct net_device *dev; 952 953 /* Find an empty slot, that is no net_device and zero io port. */ 954 this_dev = 0; 955 while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) || 956 io[this_dev]) { 957 if (++this_dev == MAX_NE_CARDS) 958 return ERR_PTR(-ENOMEM); 959 } 960 961 /* Get irq, io from kernel command line */ 962 dev = alloc_eip_netdev(); 963 if (!dev) 964 return ERR_PTR(-ENOMEM); 965 966 sprintf(dev->name, "eth%d", unit); 967 netdev_boot_setup_check(dev); 968 969 io[this_dev] = dev->base_addr; 970 irq[this_dev] = dev->irq; 971 bad[this_dev] = dev->mem_end; 972 973 free_netdev(dev); 974 975 ne_add_devices(); 976 977 /* return the first device found */ 978 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { 979 if (pdev_ne[this_dev]) { 980 dev = platform_get_drvdata(pdev_ne[this_dev]); 981 if (dev) 982 return dev; 983 } 984 } 985 986 return ERR_PTR(-ENODEV); 987 } 988 #endif 989 990 static void __exit ne_exit(void) 991 { 992 platform_driver_unregister(&ne_driver); 993 ne_loop_rm_unreg(1); 994 } 995 module_exit(ne_exit); 996