Root/drivers/net/ne2k-pci.c

1/* ne2k-pci.c: A NE2000 clone on PCI bus driver for Linux. */
2/*
3    A Linux device driver for PCI NE2000 clones.
4
5    Authors and other copyright holders:
6    1992-2000 by Donald Becker, NE2000 core and various modifications.
7    1995-1998 by Paul Gortmaker, core modifications and PCI support.
8    Copyright 1993 assigned to the United States Government as represented
9    by the Director, National Security Agency.
10
11    This software may be used and distributed according to the terms of
12    the GNU General Public License (GPL), incorporated herein by reference.
13    Drivers based on or derived from this code fall under the GPL and must
14    retain the authorship, copyright and license notice. This file is not
15    a complete program and may only be used when the entire operating
16    system is licensed under the GPL.
17
18    The author may be reached as becker@scyld.com, or C/O
19    Scyld Computing Corporation
20    410 Severn Ave., Suite 210
21    Annapolis MD 21403
22
23    Issues remaining:
24    People are making PCI ne2000 clones! Oh the horror, the horror...
25    Limited full-duplex support.
26*/
27
28#define DRV_NAME "ne2k-pci"
29#define DRV_VERSION "1.03"
30#define DRV_RELDATE "9/22/2003"
31
32
33/* The user-configurable values.
34   These may be modified when a driver module is loaded.*/
35
36static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
37
38#define MAX_UNITS 8 /* More are supported, limit only on options */
39/* Used to pass the full-duplex flag, etc. */
40static int full_duplex[MAX_UNITS];
41static int options[MAX_UNITS];
42
43/* Force a non std. amount of memory. Units are 256 byte pages. */
44/* #define PACKETBUF_MEMSIZE 0x40 */
45
46
47#include <linux/module.h>
48#include <linux/kernel.h>
49#include <linux/errno.h>
50#include <linux/pci.h>
51#include <linux/init.h>
52#include <linux/interrupt.h>
53#include <linux/ethtool.h>
54#include <linux/netdevice.h>
55#include <linux/etherdevice.h>
56
57#include <asm/system.h>
58#include <asm/io.h>
59#include <asm/irq.h>
60#include <asm/uaccess.h>
61
62#include "8390.h"
63
64/* These identify the driver base version and may not be removed. */
65static const char version[] __devinitconst =
66    KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE
67    " D. Becker/P. Gortmaker\n";
68
69#if defined(__powerpc__)
70#define inl_le(addr) le32_to_cpu(inl(addr))
71#define inw_le(addr) le16_to_cpu(inw(addr))
72#endif
73
74#define PFX DRV_NAME ": "
75
76MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
77MODULE_DESCRIPTION("PCI NE2000 clone driver");
78MODULE_LICENSE("GPL");
79
80module_param(debug, int, 0);
81module_param_array(options, int, NULL, 0);
82module_param_array(full_duplex, int, NULL, 0);
83MODULE_PARM_DESC(debug, "debug level (1-2)");
84MODULE_PARM_DESC(options, "Bit 5: full duplex");
85MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)");
86
87/* Some defines that people can play with if so inclined. */
88
89/* Use 32 bit data-movement operations instead of 16 bit. */
90#define USE_LONGIO
91
92/* Do we implement the read before write bugfix ? */
93/* #define NE_RW_BUGFIX */
94
95/* Flags. We rename an existing ei_status field to store flags! */
96/* Thus only the low 8 bits are usable for non-init-time flags. */
97#define ne2k_flags reg0
98enum {
99    ONLY_16BIT_IO=8, ONLY_32BIT_IO=4, /* Chip can do only 16/32-bit xfers. */
100    FORCE_FDX=0x20, /* User override. */
101    REALTEK_FDX=0x40, HOLTEK_FDX=0x80,
102    STOP_PG_0x60=0x100,
103};
104
105enum ne2k_pci_chipsets {
106    CH_RealTek_RTL_8029 = 0,
107    CH_Winbond_89C940,
108    CH_Compex_RL2000,
109    CH_KTI_ET32P2,
110    CH_NetVin_NV5000SC,
111    CH_Via_86C926,
112    CH_SureCom_NE34,
113    CH_Winbond_W89C940F,
114    CH_Holtek_HT80232,
115    CH_Holtek_HT80229,
116    CH_Winbond_89C940_8c4a,
117};
118
119
120static struct {
121    char *name;
122    int flags;
123} pci_clone_list[] __devinitdata = {
124    {"RealTek RTL-8029", REALTEK_FDX},
125    {"Winbond 89C940", 0},
126    {"Compex RL2000", 0},
127    {"KTI ET32P2", 0},
128    {"NetVin NV5000SC", 0},
129    {"Via 86C926", ONLY_16BIT_IO},
130    {"SureCom NE34", 0},
131    {"Winbond W89C940F", 0},
132    {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
133    {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
134    {"Winbond W89C940(misprogrammed)", 0},
135    {NULL,}
136};
137
138
139static struct pci_device_id ne2k_pci_tbl[] = {
140    { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
141    { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
142    { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
143    { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
144    { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
145    { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
146    { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
147    { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
148    { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
149    { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
150    { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
151    { 0, }
152};
153MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
154
155
156/* ---- No user-serviceable parts below ---- */
157
158#define NE_BASE (dev->base_addr)
159#define NE_CMD 0x00
160#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
161#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
162#define NE_IO_EXTENT 0x20
163
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
168static int ne2k_pci_open(struct net_device *dev);
169static int ne2k_pci_close(struct net_device *dev);
170
171static void ne2k_pci_reset_8390(struct net_device *dev);
172static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
173              int ring_page);
174static void ne2k_pci_block_input(struct net_device *dev, int count,
175              struct sk_buff *skb, int ring_offset);
176static void ne2k_pci_block_output(struct net_device *dev, const int count,
177        const unsigned char *buf, const int start_page);
178static const struct ethtool_ops ne2k_pci_ethtool_ops;
179
180
181
182/* There is no room in the standard 8390 structure for extra info we need,
183   so we build a meta/outer-wrapper structure.. */
184struct ne2k_pci_card {
185    struct net_device *dev;
186    struct pci_dev *pci_dev;
187};
188
189
190
191/*
192  NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
193  buffer memory space. By-the-spec NE2000 clones have 0x57,0x57 in bytes
194  0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
195  detected by their SA prefix.
196
197  Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
198  mode results in doubled values, which can be detected and compensated for.
199
200  The probe is also responsible for initializing the card and filling
201  in the 'dev' and 'ei_status' structures.
202*/
203
204static const struct net_device_ops ne2k_netdev_ops = {
205    .ndo_open = ne2k_pci_open,
206    .ndo_stop = ne2k_pci_close,
207    .ndo_start_xmit = ei_start_xmit,
208    .ndo_tx_timeout = ei_tx_timeout,
209    .ndo_get_stats = ei_get_stats,
210    .ndo_set_multicast_list = ei_set_multicast_list,
211    .ndo_validate_addr = eth_validate_addr,
212    .ndo_set_mac_address = eth_mac_addr,
213    .ndo_change_mtu = eth_change_mtu,
214#ifdef CONFIG_NET_POLL_CONTROLLER
215    .ndo_poll_controller = ei_poll,
216#endif
217};
218
219static int __devinit ne2k_pci_init_one (struct pci_dev *pdev,
220                     const struct pci_device_id *ent)
221{
222    struct net_device *dev;
223    int i;
224    unsigned char SA_prom[32];
225    int start_page, stop_page;
226    int irq, reg0, chip_idx = ent->driver_data;
227    static unsigned int fnd_cnt;
228    long ioaddr;
229    int flags = pci_clone_list[chip_idx].flags;
230
231/* when built into the kernel, we only print version if device is found */
232#ifndef MODULE
233    static int printed_version;
234    if (!printed_version++)
235        printk(version);
236#endif
237
238    fnd_cnt++;
239
240    i = pci_enable_device (pdev);
241    if (i)
242        return i;
243
244    ioaddr = pci_resource_start (pdev, 0);
245    irq = pdev->irq;
246
247    if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) {
248        dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
249        return -ENODEV;
250    }
251
252    if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) {
253        dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
254            NE_IO_EXTENT, ioaddr);
255        return -EBUSY;
256    }
257
258    reg0 = inb(ioaddr);
259    if (reg0 == 0xFF)
260        goto err_out_free_res;
261
262    /* Do a preliminary verification that we have a 8390. */
263    {
264        int regd;
265        outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
266        regd = inb(ioaddr + 0x0d);
267        outb(0xff, ioaddr + 0x0d);
268        outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
269        inb(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
270        if (inb(ioaddr + EN0_COUNTER0) != 0) {
271            outb(reg0, ioaddr);
272            outb(regd, ioaddr + 0x0d); /* Restore the old values. */
273            goto err_out_free_res;
274        }
275    }
276
277    /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
278    dev = alloc_ei_netdev();
279    if (!dev) {
280        dev_err(&pdev->dev, "cannot allocate ethernet device\n");
281        goto err_out_free_res;
282    }
283    dev->netdev_ops = &ne2k_netdev_ops;
284
285    SET_NETDEV_DEV(dev, &pdev->dev);
286
287    /* Reset card. Who knows what dain-bramaged state it was left in. */
288    {
289        unsigned long reset_start_time = jiffies;
290
291        outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
292
293        /* This looks like a horrible timing loop, but it should never take
294           more than a few cycles.
295        */
296        while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
297            /* Limit wait: '2' avoids jiffy roll-over. */
298            if (jiffies - reset_start_time > 2) {
299                dev_err(&pdev->dev,
300                    "Card failure (no reset ack).\n");
301                goto err_out_free_netdev;
302            }
303
304        outb(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
305    }
306
307    /* Read the 16 bytes of station address PROM.
308       We must first initialize registers, similar to NS8390_init(eifdev, 0).
309       We can't reliably read the SAPROM address without this.
310       (I learned the hard way!). */
311    {
312        struct {unsigned char value, offset; } program_seq[] = {
313            {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
314            {0x49, EN0_DCFG}, /* Set word-wide access. */
315            {0x00, EN0_RCNTLO}, /* Clear the count regs. */
316            {0x00, EN0_RCNTHI},
317            {0x00, EN0_IMR}, /* Mask completion irq. */
318            {0xFF, EN0_ISR},
319            {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
320            {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
321            {32, EN0_RCNTLO},
322            {0x00, EN0_RCNTHI},
323            {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
324            {0x00, EN0_RSARHI},
325            {E8390_RREAD+E8390_START, E8390_CMD},
326        };
327        for (i = 0; i < ARRAY_SIZE(program_seq); i++)
328            outb(program_seq[i].value, ioaddr + program_seq[i].offset);
329
330    }
331
332    /* Note: all PCI cards have at least 16 bit access, so we don't have
333       to check for 8 bit cards. Most cards permit 32 bit access. */
334    if (flags & ONLY_32BIT_IO) {
335        for (i = 0; i < 4 ; i++)
336            ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
337    } else
338        for(i = 0; i < 32 /*sizeof(SA_prom)*/; i++)
339            SA_prom[i] = inb(ioaddr + NE_DATAPORT);
340
341    /* We always set the 8390 registers for word mode. */
342    outb(0x49, ioaddr + EN0_DCFG);
343    start_page = NESM_START_PG;
344
345    stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
346
347    /* Set up the rest of the parameters. */
348    dev->irq = irq;
349    dev->base_addr = ioaddr;
350    pci_set_drvdata(pdev, dev);
351
352    ei_status.name = pci_clone_list[chip_idx].name;
353    ei_status.tx_start_page = start_page;
354    ei_status.stop_page = stop_page;
355    ei_status.word16 = 1;
356    ei_status.ne2k_flags = flags;
357    if (fnd_cnt < MAX_UNITS) {
358        if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
359            ei_status.ne2k_flags |= FORCE_FDX;
360    }
361
362    ei_status.rx_start_page = start_page + TX_PAGES;
363#ifdef PACKETBUF_MEMSIZE
364    /* Allow the packet buffer size to be overridden by know-it-alls. */
365    ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
366#endif
367
368    ei_status.reset_8390 = &ne2k_pci_reset_8390;
369    ei_status.block_input = &ne2k_pci_block_input;
370    ei_status.block_output = &ne2k_pci_block_output;
371    ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
372    ei_status.priv = (unsigned long) pdev;
373
374    dev->ethtool_ops = &ne2k_pci_ethtool_ops;
375    NS8390_init(dev, 0);
376
377    memcpy(dev->dev_addr, SA_prom, dev->addr_len);
378    memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
379
380    i = register_netdev(dev);
381    if (i)
382        goto err_out_free_netdev;
383
384    printk("%s: %s found at %#lx, IRQ %d, %pM.\n",
385           dev->name, pci_clone_list[chip_idx].name, ioaddr, dev->irq,
386           dev->dev_addr);
387
388    return 0;
389
390err_out_free_netdev:
391    free_netdev (dev);
392err_out_free_res:
393    release_region (ioaddr, NE_IO_EXTENT);
394    pci_set_drvdata (pdev, NULL);
395    return -ENODEV;
396
397}
398
399/*
400 * Magic incantation sequence for full duplex on the supported cards.
401 */
402static inline int set_realtek_fdx(struct net_device *dev)
403{
404    long ioaddr = dev->base_addr;
405
406    outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
407    outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
408    outb(0x40, ioaddr + 0x06); /* Enable full duplex */
409    outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
410    outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
411    return 0;
412}
413
414static inline int set_holtek_fdx(struct net_device *dev)
415{
416    long ioaddr = dev->base_addr;
417
418    outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
419    return 0;
420}
421
422static int ne2k_pci_set_fdx(struct net_device *dev)
423{
424    if (ei_status.ne2k_flags & REALTEK_FDX)
425        return set_realtek_fdx(dev);
426    else if (ei_status.ne2k_flags & HOLTEK_FDX)
427        return set_holtek_fdx(dev);
428
429    return -EOPNOTSUPP;
430}
431
432static int ne2k_pci_open(struct net_device *dev)
433{
434    int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED, dev->name, dev);
435    if (ret)
436        return ret;
437
438    if (ei_status.ne2k_flags & FORCE_FDX)
439        ne2k_pci_set_fdx(dev);
440
441    ei_open(dev);
442    return 0;
443}
444
445static int ne2k_pci_close(struct net_device *dev)
446{
447    ei_close(dev);
448    free_irq(dev->irq, dev);
449    return 0;
450}
451
452/* Hard reset the card. This used to pause for the same period that a
453   8390 reset command required, but that shouldn't be necessary. */
454static void ne2k_pci_reset_8390(struct net_device *dev)
455{
456    unsigned long reset_start_time = jiffies;
457
458    if (debug > 1) printk("%s: Resetting the 8390 t=%ld...",
459                          dev->name, jiffies);
460
461    outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
462
463    ei_status.txing = 0;
464    ei_status.dmaing = 0;
465
466    /* This check _should_not_ be necessary, omit eventually. */
467    while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
468        if (jiffies - reset_start_time > 2) {
469            printk("%s: ne2k_pci_reset_8390() did not complete.\n", dev->name);
470            break;
471        }
472    outb(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
473}
474
475/* Grab the 8390 specific header. Similar to the block_input routine, but
476   we don't need to be concerned with ring wrap as the header will be at
477   the start of a page, so we optimize accordingly. */
478
479static void ne2k_pci_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
480{
481
482    long nic_base = dev->base_addr;
483
484    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
485    if (ei_status.dmaing) {
486        printk("%s: DMAing conflict in ne2k_pci_get_8390_hdr "
487               "[DMAstat:%d][irqlock:%d].\n",
488               dev->name, ei_status.dmaing, ei_status.irqlock);
489        return;
490    }
491
492    ei_status.dmaing |= 0x01;
493    outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
494    outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
495    outb(0, nic_base + EN0_RCNTHI);
496    outb(0, nic_base + EN0_RSARLO); /* On page boundary */
497    outb(ring_page, nic_base + EN0_RSARHI);
498    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
499
500    if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
501        insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
502    } else {
503        *(u32*)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
504        le16_to_cpus(&hdr->count);
505    }
506
507    outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
508    ei_status.dmaing &= ~0x01;
509}
510
511/* Block input and output, similar to the Crynwr packet driver. If you
512   are porting to a new ethercard, look at the packet driver source for hints.
513   The NEx000 doesn't share the on-board packet memory -- you have to put
514   the packet out through the "remote DMA" dataport using outb. */
515
516static void ne2k_pci_block_input(struct net_device *dev, int count,
517                 struct sk_buff *skb, int ring_offset)
518{
519    long nic_base = dev->base_addr;
520    char *buf = skb->data;
521
522    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
523    if (ei_status.dmaing) {
524        printk("%s: DMAing conflict in ne2k_pci_block_input "
525               "[DMAstat:%d][irqlock:%d].\n",
526               dev->name, ei_status.dmaing, ei_status.irqlock);
527        return;
528    }
529    ei_status.dmaing |= 0x01;
530    if (ei_status.ne2k_flags & ONLY_32BIT_IO)
531        count = (count + 3) & 0xFFFC;
532    outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
533    outb(count & 0xff, nic_base + EN0_RCNTLO);
534    outb(count >> 8, nic_base + EN0_RCNTHI);
535    outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
536    outb(ring_offset >> 8, nic_base + EN0_RSARHI);
537    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
538
539    if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
540        insw(NE_BASE + NE_DATAPORT,buf,count>>1);
541        if (count & 0x01) {
542            buf[count-1] = inb(NE_BASE + NE_DATAPORT);
543        }
544    } else {
545        insl(NE_BASE + NE_DATAPORT, buf, count>>2);
546        if (count & 3) {
547            buf += count & ~3;
548            if (count & 2) {
549                __le16 *b = (__le16 *)buf;
550
551                *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
552                buf = (char *)b;
553            }
554            if (count & 1)
555                *buf = inb(NE_BASE + NE_DATAPORT);
556        }
557    }
558
559    outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
560    ei_status.dmaing &= ~0x01;
561}
562
563static void ne2k_pci_block_output(struct net_device *dev, int count,
564                  const unsigned char *buf, const int start_page)
565{
566    long nic_base = NE_BASE;
567    unsigned long dma_start;
568
569    /* On little-endian it's always safe to round the count up for
570       word writes. */
571    if (ei_status.ne2k_flags & ONLY_32BIT_IO)
572        count = (count + 3) & 0xFFFC;
573    else
574        if (count & 0x01)
575            count++;
576
577    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
578    if (ei_status.dmaing) {
579        printk("%s: DMAing conflict in ne2k_pci_block_output."
580               "[DMAstat:%d][irqlock:%d]\n",
581               dev->name, ei_status.dmaing, ei_status.irqlock);
582        return;
583    }
584    ei_status.dmaing |= 0x01;
585    /* We should already be in page 0, but to be safe... */
586    outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
587
588#ifdef NE8390_RW_BUGFIX
589    /* Handle the read-before-write bug the same way as the
590       Crynwr packet driver -- the NatSemi method doesn't work.
591       Actually this doesn't always work either, but if you have
592       problems with your NEx000 this is better than nothing! */
593    outb(0x42, nic_base + EN0_RCNTLO);
594    outb(0x00, nic_base + EN0_RCNTHI);
595    outb(0x42, nic_base + EN0_RSARLO);
596    outb(0x00, nic_base + EN0_RSARHI);
597    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
598#endif
599    outb(ENISR_RDC, nic_base + EN0_ISR);
600
601   /* Now the normal output. */
602    outb(count & 0xff, nic_base + EN0_RCNTLO);
603    outb(count >> 8, nic_base + EN0_RCNTHI);
604    outb(0x00, nic_base + EN0_RSARLO);
605    outb(start_page, nic_base + EN0_RSARHI);
606    outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
607    if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
608        outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
609    } else {
610        outsl(NE_BASE + NE_DATAPORT, buf, count>>2);
611        if (count & 3) {
612            buf += count & ~3;
613            if (count & 2) {
614                __le16 *b = (__le16 *)buf;
615
616                outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
617                buf = (char *)b;
618            }
619        }
620    }
621
622    dma_start = jiffies;
623
624    while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
625        if (jiffies - dma_start > 2) { /* Avoid clock roll-over. */
626            printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
627            ne2k_pci_reset_8390(dev);
628            NS8390_init(dev,1);
629            break;
630        }
631
632    outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
633    ei_status.dmaing &= ~0x01;
634    return;
635}
636
637static void ne2k_pci_get_drvinfo(struct net_device *dev,
638                 struct ethtool_drvinfo *info)
639{
640    struct ei_device *ei = netdev_priv(dev);
641    struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
642
643    strcpy(info->driver, DRV_NAME);
644    strcpy(info->version, DRV_VERSION);
645    strcpy(info->bus_info, pci_name(pci_dev));
646}
647
648static const struct ethtool_ops ne2k_pci_ethtool_ops = {
649    .get_drvinfo = ne2k_pci_get_drvinfo,
650};
651
652static void __devexit ne2k_pci_remove_one (struct pci_dev *pdev)
653{
654    struct net_device *dev = pci_get_drvdata(pdev);
655
656    BUG_ON(!dev);
657    unregister_netdev(dev);
658    release_region(dev->base_addr, NE_IO_EXTENT);
659    free_netdev(dev);
660    pci_disable_device(pdev);
661    pci_set_drvdata(pdev, NULL);
662}
663
664#ifdef CONFIG_PM
665static int ne2k_pci_suspend (struct pci_dev *pdev, pm_message_t state)
666{
667    struct net_device *dev = pci_get_drvdata (pdev);
668
669    netif_device_detach(dev);
670    pci_save_state(pdev);
671    pci_disable_device(pdev);
672    pci_set_power_state(pdev, pci_choose_state(pdev, state));
673
674    return 0;
675}
676
677static int ne2k_pci_resume (struct pci_dev *pdev)
678{
679    struct net_device *dev = pci_get_drvdata (pdev);
680    int rc;
681
682    pci_set_power_state(pdev, 0);
683    pci_restore_state(pdev);
684
685    rc = pci_enable_device(pdev);
686    if (rc)
687        return rc;
688
689    NS8390_init(dev, 1);
690    netif_device_attach(dev);
691
692    return 0;
693}
694
695#endif /* CONFIG_PM */
696
697
698static struct pci_driver ne2k_driver = {
699    .name = DRV_NAME,
700    .probe = ne2k_pci_init_one,
701    .remove = __devexit_p(ne2k_pci_remove_one),
702    .id_table = ne2k_pci_tbl,
703#ifdef CONFIG_PM
704    .suspend = ne2k_pci_suspend,
705    .resume = ne2k_pci_resume,
706#endif /* CONFIG_PM */
707
708};
709
710
711static int __init ne2k_pci_init(void)
712{
713/* when a module, this is printed whether or not devices are found in probe */
714#ifdef MODULE
715    printk(version);
716#endif
717    return pci_register_driver(&ne2k_driver);
718}
719
720
721static void __exit ne2k_pci_cleanup(void)
722{
723    pci_unregister_driver (&ne2k_driver);
724}
725
726module_init(ne2k_pci_init);
727module_exit(ne2k_pci_cleanup);
728

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