git.oblomov.eu Git - linux-2.6/blob - drivers/net/ne.c

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