1
/* ne.c: A general non-shared-memory NS8390 ethernet driver for linux. */
3
Written 1992-94 by Donald Becker.
5
Copyright 1993 United States Government as represented by the
6
Director, National Security Agency.
8
This software may be used and distributed according to the terms
9
of the GNU General Public License, incorporated herein by reference.
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
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.
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.
36
/* Routines for the NatSemi-based designs (NE[12]000). */
38
static const char version1[] =
39
"ne.c:v1.10 9/23/94 Donald Becker (becker@scyld.com)\n";
40
static const char version2[] =
41
"Last modified Nov 1, 2000 by Paul Gortmaker\n";
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>
56
#include <asm/system.h>
63
/* Some defines that people can play with if so inclined. */
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 */
70
#define MAX_NE_CARDS 4 /* Max number of NE cards per module */
71
static struct platform_device *pdev_ne[MAX_NE_CARDS];
72
static int io[MAX_NE_CARDS];
73
static int irq[MAX_NE_CARDS];
74
static int bad[MAX_NE_CARDS];
77
module_param_array(io, int, NULL, 0);
78
module_param_array(irq, int, NULL, 0);
79
module_param_array(bad, int, NULL, 0);
80
MODULE_PARM_DESC(io, "I/O base address(es),required");
81
MODULE_PARM_DESC(irq, "IRQ number(s)");
82
MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
83
MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
84
MODULE_LICENSE("GPL");
87
/* Do we perform extra sanity checks on stuff ? */
88
/* #define NE_SANITY_CHECK */
90
/* Do we implement the read before write bugfix ? */
91
/* #define NE_RW_BUGFIX */
93
/* Do we have a non std. amount of memory? (in units of 256 byte pages) */
94
/* #define PACKETBUF_MEMSIZE 0x40 */
96
/* This is set up so that no ISA autoprobe takes place. We can't guarantee
97
that the ne2k probe is the last 8390 based probe to take place (as it
98
is at boot) and so the probe will get confused by any other 8390 cards.
99
ISA 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
105
/* A zero-terminated list of I/O addresses to be probed at boot. */
106
#ifdef NEEDS_PORTLIST
107
static unsigned int netcard_portlist[] __initdata = {
108
0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
112
static 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 */
125
MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
127
#ifdef SUPPORT_NE_BAD_CLONES
128
/* A list of bad clones that we none-the-less recognize. */
129
static struct { const char *name8, *name16; unsigned char SAprefix[4];}
130
bad_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 */
147
{"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
152
/* ---- No user-serviceable parts below ---- */
154
#define NE_BASE (dev->base_addr)
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
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 */
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 */
171
# define DCR_VAL 0x49
174
static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
175
static int ne_probe_isapnp(struct net_device *dev);
177
static void ne_reset_8390(struct net_device *dev);
178
static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
180
static void ne_block_input(struct net_device *dev, int count,
181
struct sk_buff *skb, int ring_offset);
182
static void ne_block_output(struct net_device *dev, const int count,
183
const unsigned char *buf, const int start_page);
186
/* Probe for various non-shared-memory ethercards.
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
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.
196
The probe is also responsible for initializing the card and filling
197
in the 'dev' and 'ei_status' structures.
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. */
207
static int __init do_ne_probe(struct net_device *dev)
209
unsigned long base_addr = dev->base_addr;
210
#ifdef NEEDS_PORTLIST
211
int orig_irq = dev->irq;
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);
218
printk(KERN_WARNING "ne.c: No NE*000 card found at "
219
"i/o = %#lx\n", base_addr);
222
else if (base_addr != 0) /* Don't probe at all. */
225
/* Then look for any installed ISAPnP clones */
226
if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
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];
234
if (ne_probe1(dev, ioaddr) == 0)
242
static int __init ne_probe_isapnp(struct net_device *dev)
246
for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
247
struct pnp_dev *idev = NULL;
249
while ((idev = pnp_find_dev(NULL,
250
isapnp_clone_list[i].vendor,
251
isapnp_clone_list[i].function,
253
/* Avoid already found cards from previous calls */
254
if (pnp_device_attach(idev) < 0)
256
if (pnp_activate_dev(idev) < 0) {
257
pnp_device_detach(idev);
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);
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);
276
ei_status.priv = (unsigned long)idev;
287
static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
290
unsigned char SA_prom[32];
292
const char *name = NULL;
293
int start_page, stop_page;
294
int neX000, ctron, copam, bad_card;
296
static unsigned version_printed;
298
if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
301
reg0 = inb_p(ioaddr);
307
/* Do a preliminary verification that we have a 8390. */
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. */
323
if (ei_debug && version_printed++ == 0)
324
printk(KERN_INFO "%s%s", version1, version2);
326
printk(KERN_INFO "NE*000 ethercard probe at %#3lx:", ioaddr);
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. */
334
bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD));
336
/* Reset card. Who knows what dain-bramaged state it was left in. */
339
unsigned long reset_start_time = jiffies;
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);
344
while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
345
if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
347
printk(" (warning: no reset ack)");
350
printk(" not found (no reset ack).\n");
356
outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
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!). */
364
struct {unsigned char value, offset; } program_seq[] =
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. */
370
{0x00, EN0_IMR}, /* Mask completion irq. */
372
{E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
373
{E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
376
{0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
378
{E8390_RREAD+E8390_START, E8390_CMD},
381
for (i = 0; i < ARRAY_SIZE(program_seq); i++)
382
outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
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])
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;
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)...
406
if ((DCR_VAL & 0x01) == 0 && /* 8-bit mode */
407
inb(ioaddr + EN0_RCNTLO) == 0x50 &&
408
inb(ioaddr + EN0_RCNTHI) == 0x70)
411
stop_page = NESM_STOP_PG;
413
start_page = NE1SM_START_PG;
414
stop_page = NE1SM_STOP_PG;
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));
421
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);
426
/* Set up the rest of the parameters. */
427
if (neX000 || bad_card || copam) {
428
name = (wordlength == 2) ? "NE2000" : "NE1000";
432
name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
434
stop_page = (wordlength == 2) ? 0x40 : 0x20;
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++)
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])
449
name = bad_clone_list[i].name16;
451
name = bad_clone_list[i].name8;
456
if (bad_clone_list[i].name8 == NULL)
458
printk(" not found (invalid signature %2.2x %2.2x).\n",
459
SA_prom[14], SA_prom[15]);
464
printk(" not found.\n");
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);
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. */
488
printk(" failed to detect IRQ line.\n");
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);
497
printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
501
dev->base_addr = ioaddr;
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));
511
for(i = 0; i < ETHER_ADDR_LEN; i++) {
512
dev->dev_addr[i] = SA_prom[i];
516
printk("%pM\n", dev->dev_addr);
518
ei_status.name = name;
519
ei_status.tx_start_page = start_page;
520
ei_status.stop_page = stop_page;
522
/* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
523
ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
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;
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;
537
dev->netdev_ops = &eip_netdev_ops;
538
NS8390p_init(dev, 0);
540
ret = register_netdev(dev);
543
printk(KERN_INFO "%s: %s found at %#lx, using IRQ %d.\n",
544
dev->name, name, ioaddr, dev->irq);
548
free_irq(dev->irq, dev);
550
release_region(ioaddr, NE_IO_EXTENT);
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. */
557
static void ne_reset_8390(struct net_device *dev)
559
unsigned long reset_start_time = jiffies;
562
printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
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);
568
ei_status.dmaing = 0;
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);
576
outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
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. */
583
static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
585
int nic_base = dev->base_addr;
587
/* This *shouldn't* happen. If it does, it's the last thing you'll see */
589
if (ei_status.dmaing)
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);
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);
605
if (ei_status.word16)
606
insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
608
insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
610
outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
611
ei_status.dmaing &= ~0x01;
613
le16_to_cpus(&hdr->count);
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. */
621
static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
623
#ifdef NE_SANITY_CHECK
624
int xfer_count = count;
626
int nic_base = dev->base_addr;
627
char *buf = skb->data;
629
/* This *shouldn't* happen. If it does, it's the last thing you'll see */
630
if (ei_status.dmaing)
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);
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)
646
insw(NE_BASE + NE_DATAPORT,buf,count>>1);
649
buf[count-1] = inb(NE_BASE + NE_DATAPORT);
650
#ifdef NE_SANITY_CHECK
655
insb(NE_BASE + NE_DATAPORT, buf, count);
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. */
666
/* DMA termination address check... */
667
int addr, tries = 20;
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)
676
} while (--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);
683
outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
684
ei_status.dmaing &= ~0x01;
687
static void ne_block_output(struct net_device *dev, int count,
688
const unsigned char *buf, const int start_page)
690
int nic_base = NE_BASE;
691
unsigned long dma_start;
692
#ifdef NE_SANITY_CHECK
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. */
700
if (ei_status.word16 && (count & 0x01))
703
/* This *shouldn't* happen. If it does, it's the last thing you'll see */
704
if (ei_status.dmaing)
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);
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);
715
#ifdef NE_SANITY_CHECK
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! */
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. */
734
outb_p(ENISR_RDC, nic_base + EN0_ISR);
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);
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);
746
outsb(NE_BASE + NE_DATAPORT, buf, count);
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. */
757
/* DMA termination address check... */
758
int addr, tries = 20;
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)
765
} while (--tries > 0);
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);
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);
782
NS8390p_init(dev, 1);
786
outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
787
ei_status.dmaing &= ~0x01;
790
static int __init ne_drv_probe(struct platform_device *pdev)
792
struct net_device *dev;
793
int err, this_dev = pdev->id;
794
struct resource *res;
796
dev = alloc_eip_netdev();
800
/* ne.c doesn't populate resources in platform_device, but
801
* rbtx4927_ne_init and rbtx4938_ne_init do register devices
804
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
806
dev->base_addr = res->start;
807
dev->irq = platform_get_irq(pdev, 0);
809
if (this_dev < 0 || this_dev >= MAX_NE_CARDS) {
813
dev->base_addr = io[this_dev];
814
dev->irq = irq[this_dev];
815
dev->mem_end = bad[this_dev];
817
err = do_ne_probe(dev);
822
platform_set_drvdata(pdev, dev);
824
/* Update with any values found by probing, don't update if
825
* resources were specified.
828
io[this_dev] = dev->base_addr;
829
irq[this_dev] = dev->irq;
834
static int ne_drv_remove(struct platform_device *pdev)
836
struct net_device *dev = platform_get_drvdata(pdev);
839
struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
840
netif_device_detach(dev);
841
unregister_netdev(dev);
843
pnp_device_detach(idev);
844
/* Careful ne_drv_remove can be called twice, once from
845
* the platform_driver.remove and again when the
846
* platform_device is being removed.
849
free_irq(dev->irq, dev);
850
release_region(dev->base_addr, NE_IO_EXTENT);
852
platform_set_drvdata(pdev, NULL);
857
/* Remove unused devices or all if true. */
858
static void ne_loop_rm_unreg(int all)
861
struct platform_device *pdev;
862
for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
863
pdev = pdev_ne[this_dev];
864
/* No network device == unused */
865
if (pdev && (!platform_get_drvdata(pdev) || all)) {
867
platform_device_unregister(pdev);
868
pdev_ne[this_dev] = NULL;
874
static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
876
struct net_device *dev = platform_get_drvdata(pdev);
878
if (netif_running(dev)) {
879
struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
880
netif_device_detach(dev);
887
static int ne_drv_resume(struct platform_device *pdev)
889
struct net_device *dev = platform_get_drvdata(pdev);
891
if (netif_running(dev)) {
892
struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
896
NS8390p_init(dev, 1);
897
netif_device_attach(dev);
902
#define ne_drv_suspend NULL
903
#define ne_drv_resume NULL
906
static struct platform_driver ne_driver = {
907
.remove = ne_drv_remove,
908
.suspend = ne_drv_suspend,
909
.resume = ne_drv_resume,
912
.owner = THIS_MODULE,
916
static void __init ne_add_devices(void)
919
struct platform_device *pdev;
921
for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
922
if (pdev_ne[this_dev])
924
pdev = platform_device_register_simple(
925
DRV_NAME, this_dev, NULL, 0);
928
pdev_ne[this_dev] = pdev;
933
int __init init_module(void)
937
retval = platform_driver_probe(&ne_driver, ne_drv_probe);
940
printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\""
941
" value(s) for ISA cards.\n");
946
/* Unregister unused platform_devices. */
951
static int __init ne_init(void)
953
int retval = platform_driver_probe(&ne_driver, ne_drv_probe);
955
/* Unregister unused platform_devices. */
959
module_init(ne_init);
961
struct net_device * __init ne_probe(int unit)
964
struct net_device *dev;
966
/* Find an empty slot, that is no net_device and zero io port. */
968
while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) ||
970
if (++this_dev == MAX_NE_CARDS)
971
return ERR_PTR(-ENOMEM);
974
/* Get irq, io from kernel command line */
975
dev = alloc_eip_netdev();
977
return ERR_PTR(-ENOMEM);
979
sprintf(dev->name, "eth%d", unit);
980
netdev_boot_setup_check(dev);
982
io[this_dev] = dev->base_addr;
983
irq[this_dev] = dev->irq;
984
bad[this_dev] = dev->mem_end;
990
/* return the first device found */
991
for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
992
if (pdev_ne[this_dev]) {
993
dev = platform_get_drvdata(pdev_ne[this_dev]);
999
return ERR_PTR(-ENODEV);
1003
static void __exit ne_exit(void)
1005
platform_driver_unregister(&ne_driver);
1006
ne_loop_rm_unreg(1);
1008
module_exit(ne_exit);