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