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