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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive