drivers/net/ethernet/8390/ne.c

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