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