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