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 static u32 ne_msg_enable; 75 76 #ifdef MODULE 77 module_param_array(io, int, NULL, 0); 78 module_param_array(irq, int, NULL, 0); 79 module_param_array(bad, int, NULL, 0); 80 module_param_named(msg_enable, ne_msg_enable, uint, (S_IRUSR|S_IRGRP|S_IROTH)); 81 MODULE_PARM_DESC(io, "I/O base address(es),required"); 82 MODULE_PARM_DESC(irq, "IRQ number(s)"); 83 MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures"); 84 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)"); 85 MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver"); 86 MODULE_LICENSE("GPL"); 87 #endif /* MODULE */ 88 89 /* Do we perform extra sanity checks on stuff ? */ 90 /* #define NE_SANITY_CHECK */ 91 92 /* Do we implement the read before write bugfix ? */ 93 /* #define NE_RW_BUGFIX */ 94 95 /* Do we have a non std. amount of memory? (in units of 256 byte pages) */ 96 /* #define PACKETBUF_MEMSIZE 0x40 */ 97 98 /* This is set up so that no ISA autoprobe takes place. We can't guarantee 99 that the ne2k probe is the last 8390 based probe to take place (as it 100 is at boot) and so the probe will get confused by any other 8390 cards. 101 ISA device autoprobes on a running machine are not recommended anyway. */ 102 #if !defined(MODULE) && (defined(CONFIG_ISA) || defined(CONFIG_M32R)) 103 /* Do we need a portlist for the ISA auto-probe ? */ 104 #define NEEDS_PORTLIST 105 #endif 106 107 /* A zero-terminated list of I/O addresses to be probed at boot. */ 108 #ifdef NEEDS_PORTLIST 109 static unsigned int netcard_portlist[] __initdata = { 110 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0 111 }; 112 #endif 113 114 static struct isapnp_device_id isapnp_clone_list[] __initdata = { 115 { ISAPNP_CARD_ID('A','X','E',0x2011), 116 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011), 117 (long) "NetGear EA201" }, 118 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 119 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216), 120 (long) "NN NE2000" }, 121 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 122 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6), 123 (long) "Generic PNP" }, 124 { } /* terminate list */ 125 }; 126 127 MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list); 128 129 #ifdef SUPPORT_NE_BAD_CLONES 130 /* A list of bad clones that we none-the-less recognize. */ 131 static struct { const char *name8, *name16; unsigned char SAprefix[4];} 132 bad_clone_list[] __initdata = { 133 {"DE100", "DE200", {0x00, 0xDE, 0x01,}}, 134 {"DE120", "DE220", {0x00, 0x80, 0xc8,}}, 135 {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */ 136 {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}}, 137 {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */ 138 {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */ 139 {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */ 140 {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */ 141 {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */ 142 {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */ 143 {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */ 144 {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */ 145 {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */ 146 #ifdef CONFIG_MACH_TX49XX 147 {"RBHMA4X00-RTL8019", "RBHMA4X00-RTL8019", {0x00, 0x60, 0x0a}}, /* Toshiba built-in */ 148 #endif 149 {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */ 150 {NULL,} 151 }; 152 #endif 153 154 /* ---- No user-serviceable parts below ---- */ 155 156 #define NE_BASE (dev->base_addr) 157 #define NE_CMD 0x00 158 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */ 159 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */ 160 #define NE_IO_EXTENT 0x20 161 162 #define NE1SM_START_PG 0x20 /* First page of TX buffer */ 163 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */ 164 #define NESM_START_PG 0x40 /* First page of TX buffer */ 165 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ 166 167 #if defined(CONFIG_PLAT_MAPPI) 168 # define DCR_VAL 0x4b 169 #elif defined(CONFIG_PLAT_OAKS32R) || \ 170 defined(CONFIG_MACH_TX49XX) 171 # define DCR_VAL 0x48 /* 8-bit mode */ 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 #if defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R) 424 neX000 = ((SA_prom[14] == 0x57 && SA_prom[15] == 0x57) 425 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42)); 426 #else 427 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57); 428 #endif 429 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d); 430 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00); 431 432 /* Set up the rest of the parameters. */ 433 if (neX000 || bad_card || copam) { 434 name = (wordlength == 2) ? "NE2000" : "NE1000"; 435 } 436 else if (ctron) 437 { 438 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16"; 439 start_page = 0x01; 440 stop_page = (wordlength == 2) ? 0x40 : 0x20; 441 } 442 else 443 { 444 #ifdef SUPPORT_NE_BAD_CLONES 445 /* Ack! Well, there might be a *bad* NE*000 clone there. 446 Check for total bogus addresses. */ 447 for (i = 0; bad_clone_list[i].name8; i++) 448 { 449 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] && 450 SA_prom[1] == bad_clone_list[i].SAprefix[1] && 451 SA_prom[2] == bad_clone_list[i].SAprefix[2]) 452 { 453 if (wordlength == 2) 454 { 455 name = bad_clone_list[i].name16; 456 } else { 457 name = bad_clone_list[i].name8; 458 } 459 break; 460 } 461 } 462 if (bad_clone_list[i].name8 == NULL) 463 { 464 pr_cont(" not found (invalid signature %2.2x %2.2x).\n", 465 SA_prom[14], SA_prom[15]); 466 ret = -ENXIO; 467 goto err_out; 468 } 469 #else 470 pr_cont(" not found.\n"); 471 ret = -ENXIO; 472 goto err_out; 473 #endif 474 } 475 476 if (dev->irq < 2) 477 { 478 unsigned long cookie = probe_irq_on(); 479 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */ 480 outb_p(0x00, ioaddr + EN0_RCNTLO); 481 outb_p(0x00, ioaddr + EN0_RCNTHI); 482 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */ 483 mdelay(10); /* wait 10ms for interrupt to propagate */ 484 outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */ 485 dev->irq = probe_irq_off(cookie); 486 if (netif_msg_probe(ei_local)) 487 pr_cont(" autoirq is %d", dev->irq); 488 } else if (dev->irq == 2) 489 /* Fixup for users that don't know that IRQ 2 is really IRQ 9, 490 or don't know which one to set. */ 491 dev->irq = 9; 492 493 if (! dev->irq) { 494 pr_cont(" failed to detect IRQ line.\n"); 495 ret = -EAGAIN; 496 goto err_out; 497 } 498 499 /* Snarf the interrupt now. There's no point in waiting since we cannot 500 share and the board will usually be enabled. */ 501 ret = request_irq(dev->irq, eip_interrupt, 0, name, dev); 502 if (ret) { 503 pr_cont(" unable to get IRQ %d (errno=%d).\n", dev->irq, ret); 504 goto err_out; 505 } 506 507 dev->base_addr = ioaddr; 508 509 #ifdef CONFIG_PLAT_MAPPI 510 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, 511 ioaddr + E8390_CMD); /* 0x61 */ 512 for (i = 0; i < ETH_ALEN; i++) { 513 dev->dev_addr[i] = SA_prom[i] 514 = inb_p(ioaddr + EN1_PHYS_SHIFT(i)); 515 } 516 #else 517 for (i = 0; i < ETH_ALEN; i++) { 518 dev->dev_addr[i] = SA_prom[i]; 519 } 520 #endif 521 522 pr_cont("%pM\n", dev->dev_addr); 523 524 ei_status.name = name; 525 ei_status.tx_start_page = start_page; 526 ei_status.stop_page = stop_page; 527 528 /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */ 529 ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01)); 530 531 ei_status.rx_start_page = start_page + TX_PAGES; 532 #ifdef PACKETBUF_MEMSIZE 533 /* Allow the packet buffer size to be overridden by know-it-alls. */ 534 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE; 535 #endif 536 537 ei_status.reset_8390 = &ne_reset_8390; 538 ei_status.block_input = &ne_block_input; 539 ei_status.block_output = &ne_block_output; 540 ei_status.get_8390_hdr = &ne_get_8390_hdr; 541 ei_status.priv = 0; 542 543 dev->netdev_ops = &eip_netdev_ops; 544 NS8390p_init(dev, 0); 545 546 ei_local->msg_enable = ne_msg_enable; 547 ret = register_netdev(dev); 548 if (ret) 549 goto out_irq; 550 netdev_info(dev, "%s found at %#lx, using IRQ %d.\n", 551 name, ioaddr, dev->irq); 552 return 0; 553 554 out_irq: 555 free_irq(dev->irq, dev); 556 err_out: 557 release_region(ioaddr, NE_IO_EXTENT); 558 return ret; 559 } 560 561 /* Hard reset the card. This used to pause for the same period that a 562 8390 reset command required, but that shouldn't be necessary. */ 563 564 static void ne_reset_8390(struct net_device *dev) 565 { 566 unsigned long reset_start_time = jiffies; 567 struct ei_device *ei_local = netdev_priv(dev); 568 569 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n", jiffies); 570 571 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ 572 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); 573 574 ei_status.txing = 0; 575 ei_status.dmaing = 0; 576 577 /* This check _should_not_ be necessary, omit eventually. */ 578 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0) 579 if (time_after(jiffies, reset_start_time + 2*HZ/100)) { 580 netdev_err(dev, "ne_reset_8390() did not complete.\n"); 581 break; 582 } 583 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */ 584 } 585 586 /* Grab the 8390 specific header. Similar to the block_input routine, but 587 we don't need to be concerned with ring wrap as the header will be at 588 the start of a page, so we optimize accordingly. */ 589 590 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 591 { 592 int nic_base = dev->base_addr; 593 594 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 595 596 if (ei_status.dmaing) 597 { 598 netdev_err(dev, "DMAing conflict in ne_get_8390_hdr " 599 "[DMAstat:%d][irqlock:%d].\n", 600 ei_status.dmaing, ei_status.irqlock); 601 return; 602 } 603 604 ei_status.dmaing |= 0x01; 605 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); 606 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO); 607 outb_p(0, nic_base + EN0_RCNTHI); 608 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */ 609 outb_p(ring_page, nic_base + EN0_RSARHI); 610 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 611 612 if (ei_status.word16) 613 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1); 614 else 615 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)); 616 617 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ 618 ei_status.dmaing &= ~0x01; 619 620 le16_to_cpus(&hdr->count); 621 } 622 623 /* Block input and output, similar to the Crynwr packet driver. If you 624 are porting to a new ethercard, look at the packet driver source for hints. 625 The NEx000 doesn't share the on-board packet memory -- you have to put 626 the packet out through the "remote DMA" dataport using outb. */ 627 628 static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 629 { 630 #ifdef NE_SANITY_CHECK 631 int xfer_count = count; 632 struct ei_device *ei_local = netdev_priv(dev); 633 #endif 634 int nic_base = dev->base_addr; 635 char *buf = skb->data; 636 637 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 638 if (ei_status.dmaing) 639 { 640 netdev_err(dev, "DMAing conflict in ne_block_input " 641 "[DMAstat:%d][irqlock:%d].\n", 642 ei_status.dmaing, ei_status.irqlock); 643 return; 644 } 645 ei_status.dmaing |= 0x01; 646 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); 647 outb_p(count & 0xff, nic_base + EN0_RCNTLO); 648 outb_p(count >> 8, nic_base + EN0_RCNTHI); 649 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO); 650 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI); 651 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 652 if (ei_status.word16) 653 { 654 insw(NE_BASE + NE_DATAPORT,buf,count>>1); 655 if (count & 0x01) 656 { 657 buf[count-1] = inb(NE_BASE + NE_DATAPORT); 658 #ifdef NE_SANITY_CHECK 659 xfer_count++; 660 #endif 661 } 662 } else { 663 insb(NE_BASE + NE_DATAPORT, buf, count); 664 } 665 666 #ifdef NE_SANITY_CHECK 667 /* This was for the ALPHA version only, but enough people have 668 been encountering problems so it is still here. If you see 669 this message you either 1) have a slightly incompatible clone 670 or 2) have noise/speed problems with your bus. */ 671 672 if (netif_msg_rx_status(ei_local)) 673 { 674 /* DMA termination address check... */ 675 int addr, tries = 20; 676 do { 677 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here 678 -- it's broken for Rx on some cards! */ 679 int high = inb_p(nic_base + EN0_RSARHI); 680 int low = inb_p(nic_base + EN0_RSARLO); 681 addr = (high << 8) + low; 682 if (((ring_offset + xfer_count) & 0xff) == low) 683 break; 684 } while (--tries > 0); 685 if (tries <= 0) 686 netdev_warn(dev, "RX transfer address mismatch," 687 "%#4.4x (expected) vs. %#4.4x (actual).\n", 688 ring_offset + xfer_count, addr); 689 } 690 #endif 691 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ 692 ei_status.dmaing &= ~0x01; 693 } 694 695 static void ne_block_output(struct net_device *dev, int count, 696 const unsigned char *buf, const int start_page) 697 { 698 int nic_base = NE_BASE; 699 unsigned long dma_start; 700 #ifdef NE_SANITY_CHECK 701 int retries = 0; 702 struct ei_device *ei_local = netdev_priv(dev); 703 #endif 704 705 /* Round the count up for word writes. Do we need to do this? 706 What effect will an odd byte count have on the 8390? 707 I should check someday. */ 708 709 if (ei_status.word16 && (count & 0x01)) 710 count++; 711 712 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 713 if (ei_status.dmaing) 714 { 715 netdev_err(dev, "DMAing conflict in ne_block_output." 716 "[DMAstat:%d][irqlock:%d]\n", 717 ei_status.dmaing, ei_status.irqlock); 718 return; 719 } 720 ei_status.dmaing |= 0x01; 721 /* We should already be in page 0, but to be safe... */ 722 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); 723 724 #ifdef NE_SANITY_CHECK 725 retry: 726 #endif 727 728 #ifdef NE8390_RW_BUGFIX 729 /* Handle the read-before-write bug the same way as the 730 Crynwr packet driver -- the NatSemi method doesn't work. 731 Actually this doesn't always work either, but if you have 732 problems with your NEx000 this is better than nothing! */ 733 734 outb_p(0x42, nic_base + EN0_RCNTLO); 735 outb_p(0x00, nic_base + EN0_RCNTHI); 736 outb_p(0x42, nic_base + EN0_RSARLO); 737 outb_p(0x00, nic_base + EN0_RSARHI); 738 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); 739 /* Make certain that the dummy read has occurred. */ 740 udelay(6); 741 #endif 742 743 outb_p(ENISR_RDC, nic_base + EN0_ISR); 744 745 /* Now the normal output. */ 746 outb_p(count & 0xff, nic_base + EN0_RCNTLO); 747 outb_p(count >> 8, nic_base + EN0_RCNTHI); 748 outb_p(0x00, nic_base + EN0_RSARLO); 749 outb_p(start_page, nic_base + EN0_RSARHI); 750 751 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD); 752 if (ei_status.word16) { 753 outsw(NE_BASE + NE_DATAPORT, buf, count>>1); 754 } else { 755 outsb(NE_BASE + NE_DATAPORT, buf, count); 756 } 757 758 dma_start = jiffies; 759 760 #ifdef NE_SANITY_CHECK 761 /* This was for the ALPHA version only, but enough people have 762 been encountering problems so it is still here. */ 763 764 if (netif_msg_tx_queued(ei_local)) 765 { 766 /* DMA termination address check... */ 767 int addr, tries = 20; 768 do { 769 int high = inb_p(nic_base + EN0_RSARHI); 770 int low = inb_p(nic_base + EN0_RSARLO); 771 addr = (high << 8) + low; 772 if ((start_page << 8) + count == addr) 773 break; 774 } while (--tries > 0); 775 776 if (tries <= 0) 777 { 778 netdev_warn(dev, "Tx packet transfer address mismatch," 779 "%#4.4x (expected) vs. %#4.4x (actual).\n", 780 (start_page << 8) + count, addr); 781 if (retries++ == 0) 782 goto retry; 783 } 784 } 785 #endif 786 787 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0) 788 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */ 789 netdev_warn(dev, "timeout waiting for Tx RDC.\n"); 790 ne_reset_8390(dev); 791 NS8390p_init(dev, 1); 792 break; 793 } 794 795 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ 796 ei_status.dmaing &= ~0x01; 797 } 798 799 static int __init ne_drv_probe(struct platform_device *pdev) 800 { 801 struct net_device *dev; 802 int err, this_dev = pdev->id; 803 struct resource *res; 804 805 dev = alloc_eip_netdev(); 806 if (!dev) 807 return -ENOMEM; 808 809 /* ne.c doesn't populate resources in platform_device, but 810 * rbtx4927_ne_init and rbtx4938_ne_init do register devices 811 * with resources. 812 */ 813 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 814 if (res) { 815 dev->base_addr = res->start; 816 dev->irq = platform_get_irq(pdev, 0); 817 } else { 818 if (this_dev < 0 || this_dev >= MAX_NE_CARDS) { 819 free_netdev(dev); 820 return -EINVAL; 821 } 822 dev->base_addr = io[this_dev]; 823 dev->irq = irq[this_dev]; 824 dev->mem_end = bad[this_dev]; 825 } 826 SET_NETDEV_DEV(dev, &pdev->dev); 827 err = do_ne_probe(dev); 828 if (err) { 829 free_netdev(dev); 830 return err; 831 } 832 platform_set_drvdata(pdev, dev); 833 834 /* Update with any values found by probing, don't update if 835 * resources were specified. 836 */ 837 if (!res) { 838 io[this_dev] = dev->base_addr; 839 irq[this_dev] = dev->irq; 840 } 841 return 0; 842 } 843 844 static int ne_drv_remove(struct platform_device *pdev) 845 { 846 struct net_device *dev = platform_get_drvdata(pdev); 847 848 if (dev) { 849 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; 850 netif_device_detach(dev); 851 unregister_netdev(dev); 852 if (idev) 853 pnp_device_detach(idev); 854 /* Careful ne_drv_remove can be called twice, once from 855 * the platform_driver.remove and again when the 856 * platform_device is being removed. 857 */ 858 ei_status.priv = 0; 859 free_irq(dev->irq, dev); 860 release_region(dev->base_addr, NE_IO_EXTENT); 861 free_netdev(dev); 862 } 863 return 0; 864 } 865 866 /* Remove unused devices or all if true. */ 867 static void ne_loop_rm_unreg(int all) 868 { 869 int this_dev; 870 struct platform_device *pdev; 871 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { 872 pdev = pdev_ne[this_dev]; 873 /* No network device == unused */ 874 if (pdev && (!platform_get_drvdata(pdev) || all)) { 875 ne_drv_remove(pdev); 876 platform_device_unregister(pdev); 877 pdev_ne[this_dev] = NULL; 878 } 879 } 880 } 881 882 #ifdef CONFIG_PM 883 static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state) 884 { 885 struct net_device *dev = platform_get_drvdata(pdev); 886 887 if (netif_running(dev)) { 888 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; 889 netif_device_detach(dev); 890 if (idev) 891 pnp_stop_dev(idev); 892 } 893 return 0; 894 } 895 896 static int ne_drv_resume(struct platform_device *pdev) 897 { 898 struct net_device *dev = platform_get_drvdata(pdev); 899 900 if (netif_running(dev)) { 901 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; 902 if (idev) 903 pnp_start_dev(idev); 904 ne_reset_8390(dev); 905 NS8390p_init(dev, 1); 906 netif_device_attach(dev); 907 } 908 return 0; 909 } 910 #else 911 #define ne_drv_suspend NULL 912 #define ne_drv_resume NULL 913 #endif 914 915 static struct platform_driver ne_driver = { 916 .remove = ne_drv_remove, 917 .suspend = ne_drv_suspend, 918 .resume = ne_drv_resume, 919 .driver = { 920 .name = DRV_NAME, 921 .owner = THIS_MODULE, 922 }, 923 }; 924 925 static void __init ne_add_devices(void) 926 { 927 int this_dev; 928 struct platform_device *pdev; 929 930 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { 931 if (pdev_ne[this_dev]) 932 continue; 933 pdev = platform_device_register_simple( 934 DRV_NAME, this_dev, NULL, 0); 935 if (IS_ERR(pdev)) 936 continue; 937 pdev_ne[this_dev] = pdev; 938 } 939 } 940 941 #ifdef MODULE 942 int __init init_module(void) 943 { 944 int retval; 945 ne_add_devices(); 946 retval = platform_driver_probe(&ne_driver, ne_drv_probe); 947 if (retval) { 948 if (io[0] == 0) 949 pr_notice("ne.c: You must supply \"io=0xNNN\"" 950 " value(s) for ISA cards.\n"); 951 ne_loop_rm_unreg(1); 952 return retval; 953 } 954 955 /* Unregister unused platform_devices. */ 956 ne_loop_rm_unreg(0); 957 return retval; 958 } 959 #else /* MODULE */ 960 static int __init ne_init(void) 961 { 962 int retval = platform_driver_probe(&ne_driver, ne_drv_probe); 963 964 /* Unregister unused platform_devices. */ 965 ne_loop_rm_unreg(0); 966 return retval; 967 } 968 module_init(ne_init); 969 970 struct net_device * __init ne_probe(int unit) 971 { 972 int this_dev; 973 struct net_device *dev; 974 975 /* Find an empty slot, that is no net_device and zero io port. */ 976 this_dev = 0; 977 while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) || 978 io[this_dev]) { 979 if (++this_dev == MAX_NE_CARDS) 980 return ERR_PTR(-ENOMEM); 981 } 982 983 /* Get irq, io from kernel command line */ 984 dev = alloc_eip_netdev(); 985 if (!dev) 986 return ERR_PTR(-ENOMEM); 987 988 sprintf(dev->name, "eth%d", unit); 989 netdev_boot_setup_check(dev); 990 991 io[this_dev] = dev->base_addr; 992 irq[this_dev] = dev->irq; 993 bad[this_dev] = dev->mem_end; 994 995 free_netdev(dev); 996 997 ne_add_devices(); 998 999 /* return the first device found */ 1000 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { 1001 if (pdev_ne[this_dev]) { 1002 dev = platform_get_drvdata(pdev_ne[this_dev]); 1003 if (dev) 1004 return dev; 1005 } 1006 } 1007 1008 return ERR_PTR(-ENODEV); 1009 } 1010 #endif /* MODULE */ 1011 1012 static void __exit ne_exit(void) 1013 { 1014 platform_driver_unregister(&ne_driver); 1015 ne_loop_rm_unreg(1); 1016 } 1017 module_exit(ne_exit); 1018