blob: 79599900c4b5a1783b5d21468461a0d02b2ccb63 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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>
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -080053#include <linux/jiffies.h>
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +090054#include <linux/platform_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
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
68/* Do we perform extra sanity checks on stuff ? */
69/* #define NE_SANITY_CHECK */
70
71/* Do we implement the read before write bugfix ? */
72/* #define NE_RW_BUGFIX */
73
74/* Do we have a non std. amount of memory? (in units of 256 byte pages) */
75/* #define PACKETBUF_MEMSIZE 0x40 */
76
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +090077#if !defined(MODULE) && (defined(CONFIG_ISA) || defined(CONFIG_M32R))
78/* Do we need a portlist for the ISA auto-probe ? */
79#define NEEDS_PORTLIST
80#endif
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082/* A zero-terminated list of I/O addresses to be probed at boot. */
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +090083#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static unsigned int netcard_portlist[] __initdata = {
85 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
86};
87#endif
88
89static struct isapnp_device_id isapnp_clone_list[] __initdata = {
90 { ISAPNP_CARD_ID('A','X','E',0x2011),
91 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011),
92 (long) "NetGear EA201" },
93 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
94 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216),
95 (long) "NN NE2000" },
96 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
97 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6),
98 (long) "Generic PNP" },
99 { } /* terminate list */
100};
101
102MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
103
104#ifdef SUPPORT_NE_BAD_CLONES
105/* A list of bad clones that we none-the-less recognize. */
106static struct { const char *name8, *name16; unsigned char SAprefix[4];}
107bad_clone_list[] __initdata = {
108 {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
109 {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
110 {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */
111 {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
112 {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
113 {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
114 {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */
115 {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
116 {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */
117 {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */
118 {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
119 {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */
120 {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */
Atsushi Nemotoc7e65c12008-08-08 00:55:17 +0900121#ifdef CONFIG_MACH_TX49XX
Ralf Baechle9cc975e2005-10-10 14:51:21 +0100122 {"RBHMA4X00-RTL8019", "RBHMA4X00/RTL8019", {0x00, 0x60, 0x0a}}, /* Toshiba built-in */
123#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
125 {NULL,}
126};
127#endif
128
129/* ---- No user-serviceable parts below ---- */
130
131#define NE_BASE (dev->base_addr)
132#define NE_CMD 0x00
133#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
134#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
135#define NE_IO_EXTENT 0x20
136
137#define NE1SM_START_PG 0x20 /* First page of TX buffer */
138#define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
139#define NESM_START_PG 0x40 /* First page of TX buffer */
140#define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
141
Olaf Hering44456d32005-07-27 11:45:17 -0700142#if defined(CONFIG_PLAT_MAPPI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143# define DCR_VAL 0x4b
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400144#elif defined(CONFIG_PLAT_OAKS32R) || \
Atsushi Nemotoc7e65c12008-08-08 00:55:17 +0900145 defined(CONFIG_MACH_TX49XX)
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400146# define DCR_VAL 0x48 /* 8-bit mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147#else
148# define DCR_VAL 0x49
149#endif
150
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900151static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152static int ne_probe_isapnp(struct net_device *dev);
153
154static int ne_open(struct net_device *dev);
155static int ne_close(struct net_device *dev);
156
157static void ne_reset_8390(struct net_device *dev);
158static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
159 int ring_page);
160static void ne_block_input(struct net_device *dev, int count,
161 struct sk_buff *skb, int ring_offset);
162static void ne_block_output(struct net_device *dev, const int count,
163 const unsigned char *buf, const int start_page);
164
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166/* Probe for various non-shared-memory ethercards.
167
168 NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
169 buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
170 the SAPROM, while other supposed NE2000 clones must be detected by their
171 SA prefix.
172
173 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
174 mode results in doubled values, which can be detected and compensated for.
175
176 The probe is also responsible for initializing the card and filling
177 in the 'dev' and 'ei_status' structures.
178
179 We use the minimum memory size for some ethercard product lines, iff we can't
180 distinguish models. You can increase the packet buffer size by setting
181 PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are:
182 E1010 starts at 0x100 and ends at 0x2000.
183 E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
184 E2010 starts at 0x100 and ends at 0x4000.
185 E2010-x starts at 0x100 and ends at 0xffff. */
186
187static int __init do_ne_probe(struct net_device *dev)
188{
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900189 unsigned long base_addr = dev->base_addr;
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900190#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 int orig_irq = dev->irq;
192#endif
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 /* First check any supplied i/o locations. User knows best. <cough> */
195 if (base_addr > 0x1ff) /* Check a single specified location. */
196 return ne_probe1(dev, base_addr);
197 else if (base_addr != 0) /* Don't probe at all. */
198 return -ENXIO;
199
200 /* Then look for any installed ISAPnP clones */
201 if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
202 return 0;
203
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900204#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 /* Last resort. The semi-risky ISA auto-probe. */
206 for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
207 int ioaddr = netcard_portlist[base_addr];
208 dev->irq = orig_irq;
209 if (ne_probe1(dev, ioaddr) == 0)
210 return 0;
211 }
212#endif
213
214 return -ENODEV;
215}
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217#ifndef MODULE
218struct net_device * __init ne_probe(int unit)
219{
Alan Cox055e5112008-07-03 23:43:12 -0700220 struct net_device *dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 int err;
222
223 if (!dev)
224 return ERR_PTR(-ENOMEM);
225
226 sprintf(dev->name, "eth%d", unit);
227 netdev_boot_setup_check(dev);
228
229 err = do_ne_probe(dev);
230 if (err)
231 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233out:
234 free_netdev(dev);
235 return ERR_PTR(err);
236}
237#endif
238
239static int __init ne_probe_isapnp(struct net_device *dev)
240{
241 int i;
242
243 for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
244 struct pnp_dev *idev = NULL;
245
246 while ((idev = pnp_find_dev(NULL,
247 isapnp_clone_list[i].vendor,
248 isapnp_clone_list[i].function,
249 idev))) {
250 /* Avoid already found cards from previous calls */
251 if (pnp_device_attach(idev) < 0)
252 continue;
253 if (pnp_activate_dev(idev) < 0) {
254 pnp_device_detach(idev);
255 continue;
256 }
257 /* if no io and irq, search for next */
258 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
259 pnp_device_detach(idev);
260 continue;
261 }
262 /* found it */
263 dev->base_addr = pnp_port_start(idev, 0);
264 dev->irq = pnp_irq(idev, 0);
265 printk(KERN_INFO "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
266 (char *) isapnp_clone_list[i].driver_data,
267 dev->base_addr, dev->irq);
268 if (ne_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
269 printk(KERN_ERR "ne.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
270 pnp_device_detach(idev);
271 return -ENXIO;
272 }
273 ei_status.priv = (unsigned long)idev;
274 break;
275 }
276 if (!idev)
277 continue;
278 return 0;
279 }
280
281 return -ENODEV;
282}
283
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900284static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
286 int i;
287 unsigned char SA_prom[32];
288 int wordlength = 2;
289 const char *name = NULL;
290 int start_page, stop_page;
291 int neX000, ctron, copam, bad_card;
292 int reg0, ret;
293 static unsigned version_printed;
Joe Perches0795af52007-10-03 17:59:30 -0700294 DECLARE_MAC_BUF(mac);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
297 return -EBUSY;
298
299 reg0 = inb_p(ioaddr);
300 if (reg0 == 0xFF) {
301 ret = -ENODEV;
302 goto err_out;
303 }
304
305 /* Do a preliminary verification that we have a 8390. */
306 {
307 int regd;
308 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
309 regd = inb_p(ioaddr + 0x0d);
310 outb_p(0xff, ioaddr + 0x0d);
311 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
312 inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
313 if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
314 outb_p(reg0, ioaddr);
315 outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */
316 ret = -ENODEV;
317 goto err_out;
318 }
319 }
320
321 if (ei_debug && version_printed++ == 0)
322 printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2);
323
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900324 printk(KERN_INFO "NE*000 ethercard probe at %#3lx:", ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 /* A user with a poor card that fails to ack the reset, or that
327 does not have a valid 0x57,0x57 signature can still use this
328 without having to recompile. Specifying an i/o address along
329 with an otherwise unused dev->mem_end value of "0xBAD" will
330 cause the driver to skip these parts of the probe. */
331
332 bad_card = ((dev->base_addr != 0) && (dev->mem_end == 0xbad));
333
334 /* Reset card. Who knows what dain-bramaged state it was left in. */
335
336 {
337 unsigned long reset_start_time = jiffies;
338
339 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
340 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
341
342 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800343 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (bad_card) {
345 printk(" (warning: no reset ack)");
346 break;
347 } else {
348 printk(" not found (no reset ack).\n");
349 ret = -ENODEV;
350 goto err_out;
351 }
352 }
353
354 outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
355 }
356
357 /* Read the 16 bytes of station address PROM.
Ingo Molnarf0084a32008-07-22 09:23:34 +0200358 We must first initialize registers, similar to NS8390p_init(eifdev, 0).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 We can't reliably read the SAPROM address without this.
360 (I learned the hard way!). */
361 {
362 struct {unsigned char value, offset; } program_seq[] =
363 {
364 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
365 {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
366 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
367 {0x00, EN0_RCNTHI},
368 {0x00, EN0_IMR}, /* Mask completion irq. */
369 {0xFF, EN0_ISR},
370 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
371 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
372 {32, EN0_RCNTLO},
373 {0x00, EN0_RCNTHI},
374 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
375 {0x00, EN0_RSARHI},
376 {E8390_RREAD+E8390_START, E8390_CMD},
377 };
378
Denis Chengff8ac602007-09-02 18:30:18 +0800379 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
381
382 }
383 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
384 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
385 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
386 if (SA_prom[i] != SA_prom[i+1])
387 wordlength = 1;
388 }
389
390 if (wordlength == 2)
391 {
392 for (i = 0; i < 16; i++)
393 SA_prom[i] = SA_prom[i+i];
394 /* We must set the 8390 for word mode. */
395 outb_p(DCR_VAL, ioaddr + EN0_DCFG);
396 start_page = NESM_START_PG;
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400397
398 /*
399 * Realtek RTL8019AS datasheet says that the PSTOP register
400 * shouldn't exceed 0x60 in 8-bit mode.
401 * This chip can be identified by reading the signature from
402 * the remote byte count registers (otherwise write-only)...
403 */
404 if ((DCR_VAL & 0x01) == 0 && /* 8-bit mode */
405 inb(ioaddr + EN0_RCNTLO) == 0x50 &&
406 inb(ioaddr + EN0_RCNTHI) == 0x70)
407 stop_page = 0x60;
408 else
409 stop_page = NESM_STOP_PG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 } else {
411 start_page = NE1SM_START_PG;
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400412 stop_page = NE1SM_STOP_PG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 }
414
415#if defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
416 neX000 = ((SA_prom[14] == 0x57 && SA_prom[15] == 0x57)
417 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
418#else
419 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
420#endif
421 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
422 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
423
424 /* Set up the rest of the parameters. */
425 if (neX000 || bad_card || copam) {
426 name = (wordlength == 2) ? "NE2000" : "NE1000";
427 }
428 else if (ctron)
429 {
430 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
431 start_page = 0x01;
432 stop_page = (wordlength == 2) ? 0x40 : 0x20;
433 }
434 else
435 {
436#ifdef SUPPORT_NE_BAD_CLONES
437 /* Ack! Well, there might be a *bad* NE*000 clone there.
438 Check for total bogus addresses. */
439 for (i = 0; bad_clone_list[i].name8; i++)
440 {
441 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
442 SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
443 SA_prom[2] == bad_clone_list[i].SAprefix[2])
444 {
445 if (wordlength == 2)
446 {
447 name = bad_clone_list[i].name16;
448 } else {
449 name = bad_clone_list[i].name8;
450 }
451 break;
452 }
453 }
454 if (bad_clone_list[i].name8 == NULL)
455 {
456 printk(" not found (invalid signature %2.2x %2.2x).\n",
457 SA_prom[14], SA_prom[15]);
458 ret = -ENXIO;
459 goto err_out;
460 }
461#else
462 printk(" not found.\n");
463 ret = -ENXIO;
464 goto err_out;
465#endif
466 }
467
468 if (dev->irq < 2)
469 {
470 unsigned long cookie = probe_irq_on();
471 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */
472 outb_p(0x00, ioaddr + EN0_RCNTLO);
473 outb_p(0x00, ioaddr + EN0_RCNTHI);
474 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
475 mdelay(10); /* wait 10ms for interrupt to propagate */
476 outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */
477 dev->irq = probe_irq_off(cookie);
478 if (ei_debug > 2)
479 printk(" autoirq is %d\n", dev->irq);
480 } else if (dev->irq == 2)
481 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
482 or don't know which one to set. */
483 dev->irq = 9;
484
485 if (! dev->irq) {
486 printk(" failed to detect IRQ line.\n");
487 ret = -EAGAIN;
488 goto err_out;
489 }
490
491 /* Snarf the interrupt now. There's no point in waiting since we cannot
492 share and the board will usually be enabled. */
Alan Cox055e5112008-07-03 23:43:12 -0700493 ret = request_irq(dev->irq, eip_interrupt, 0, name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (ret) {
495 printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
496 goto err_out;
497 }
498
499 dev->base_addr = ioaddr;
500
501#ifdef CONFIG_PLAT_MAPPI
502 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
503 ioaddr + E8390_CMD); /* 0x61 */
504 for (i = 0 ; i < ETHER_ADDR_LEN ; i++) {
505 dev->dev_addr[i] = SA_prom[i]
506 = inb_p(ioaddr + EN1_PHYS_SHIFT(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
508#else
509 for(i = 0; i < ETHER_ADDR_LEN; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 dev->dev_addr[i] = SA_prom[i];
511 }
512#endif
513
Joe Perches0795af52007-10-03 17:59:30 -0700514 printk("%s\n", print_mac(mac, dev->dev_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516 ei_status.name = name;
517 ei_status.tx_start_page = start_page;
518 ei_status.stop_page = stop_page;
Ralf Baechle9cc975e2005-10-10 14:51:21 +0100519
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400520 /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
521 ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
523 ei_status.rx_start_page = start_page + TX_PAGES;
524#ifdef PACKETBUF_MEMSIZE
525 /* Allow the packet buffer size to be overridden by know-it-alls. */
526 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
527#endif
528
529 ei_status.reset_8390 = &ne_reset_8390;
530 ei_status.block_input = &ne_block_input;
531 ei_status.block_output = &ne_block_output;
532 ei_status.get_8390_hdr = &ne_get_8390_hdr;
533 ei_status.priv = 0;
534 dev->open = &ne_open;
535 dev->stop = &ne_close;
536#ifdef CONFIG_NET_POLL_CONTROLLER
Alan Cox055e5112008-07-03 23:43:12 -0700537 dev->poll_controller = eip_poll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538#endif
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200539 NS8390p_init(dev, 0);
b1fc5502005-05-12 20:11:55 -0400540
541 ret = register_netdev(dev);
542 if (ret)
543 goto out_irq;
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900544 printk(KERN_INFO "%s: %s found at %#lx, using IRQ %d.\n",
545 dev->name, name, ioaddr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 return 0;
547
b1fc5502005-05-12 20:11:55 -0400548out_irq:
549 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550err_out:
551 release_region(ioaddr, NE_IO_EXTENT);
552 return ret;
553}
554
555static int ne_open(struct net_device *dev)
556{
Alan Cox055e5112008-07-03 23:43:12 -0700557 eip_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return 0;
559}
560
561static int ne_close(struct net_device *dev)
562{
563 if (ei_debug > 1)
564 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
Alan Cox055e5112008-07-03 23:43:12 -0700565 eip_close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 return 0;
567}
568
569/* Hard reset the card. This used to pause for the same period that a
570 8390 reset command required, but that shouldn't be necessary. */
571
572static void ne_reset_8390(struct net_device *dev)
573{
574 unsigned long reset_start_time = jiffies;
575
576 if (ei_debug > 1)
577 printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
578
579 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
580 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
581
582 ei_status.txing = 0;
583 ei_status.dmaing = 0;
584
585 /* This check _should_not_ be necessary, omit eventually. */
586 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800587 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", dev->name);
589 break;
590 }
591 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
592}
593
594/* Grab the 8390 specific header. Similar to the block_input routine, but
595 we don't need to be concerned with ring wrap as the header will be at
596 the start of a page, so we optimize accordingly. */
597
598static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
599{
600 int nic_base = dev->base_addr;
601
602 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
603
604 if (ei_status.dmaing)
605 {
606 printk(KERN_EMERG "%s: DMAing conflict in ne_get_8390_hdr "
607 "[DMAstat:%d][irqlock:%d].\n",
608 dev->name, ei_status.dmaing, ei_status.irqlock);
609 return;
610 }
611
612 ei_status.dmaing |= 0x01;
613 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
614 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
615 outb_p(0, nic_base + EN0_RCNTHI);
616 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
617 outb_p(ring_page, nic_base + EN0_RSARHI);
618 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
619
620 if (ei_status.word16)
621 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
622 else
623 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
624
625 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
626 ei_status.dmaing &= ~0x01;
627
628 le16_to_cpus(&hdr->count);
629}
630
631/* Block input and output, similar to the Crynwr packet driver. If you
632 are porting to a new ethercard, look at the packet driver source for hints.
633 The NEx000 doesn't share the on-board packet memory -- you have to put
634 the packet out through the "remote DMA" dataport using outb. */
635
636static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
637{
638#ifdef NE_SANITY_CHECK
639 int xfer_count = count;
640#endif
641 int nic_base = dev->base_addr;
642 char *buf = skb->data;
643
644 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
645 if (ei_status.dmaing)
646 {
647 printk(KERN_EMERG "%s: DMAing conflict in ne_block_input "
648 "[DMAstat:%d][irqlock:%d].\n",
649 dev->name, ei_status.dmaing, ei_status.irqlock);
650 return;
651 }
652 ei_status.dmaing |= 0x01;
653 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
654 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
655 outb_p(count >> 8, nic_base + EN0_RCNTHI);
656 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
657 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
658 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
659 if (ei_status.word16)
660 {
661 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
662 if (count & 0x01)
663 {
664 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
665#ifdef NE_SANITY_CHECK
666 xfer_count++;
667#endif
668 }
669 } else {
670 insb(NE_BASE + NE_DATAPORT, buf, count);
671 }
672
673#ifdef NE_SANITY_CHECK
674 /* This was for the ALPHA version only, but enough people have
675 been encountering problems so it is still here. If you see
676 this message you either 1) have a slightly incompatible clone
677 or 2) have noise/speed problems with your bus. */
678
679 if (ei_debug > 1)
680 {
681 /* DMA termination address check... */
682 int addr, tries = 20;
683 do {
684 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
685 -- it's broken for Rx on some cards! */
686 int high = inb_p(nic_base + EN0_RSARHI);
687 int low = inb_p(nic_base + EN0_RSARLO);
688 addr = (high << 8) + low;
689 if (((ring_offset + xfer_count) & 0xff) == low)
690 break;
691 } while (--tries > 0);
692 if (tries <= 0)
693 printk(KERN_WARNING "%s: RX transfer address mismatch,"
694 "%#4.4x (expected) vs. %#4.4x (actual).\n",
695 dev->name, ring_offset + xfer_count, addr);
696 }
697#endif
698 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
699 ei_status.dmaing &= ~0x01;
700}
701
702static void ne_block_output(struct net_device *dev, int count,
703 const unsigned char *buf, const int start_page)
704{
705 int nic_base = NE_BASE;
706 unsigned long dma_start;
707#ifdef NE_SANITY_CHECK
708 int retries = 0;
709#endif
710
711 /* Round the count up for word writes. Do we need to do this?
712 What effect will an odd byte count have on the 8390?
713 I should check someday. */
714
715 if (ei_status.word16 && (count & 0x01))
716 count++;
717
718 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
719 if (ei_status.dmaing)
720 {
721 printk(KERN_EMERG "%s: DMAing conflict in ne_block_output."
722 "[DMAstat:%d][irqlock:%d]\n",
723 dev->name, ei_status.dmaing, ei_status.irqlock);
724 return;
725 }
726 ei_status.dmaing |= 0x01;
727 /* We should already be in page 0, but to be safe... */
728 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
729
730#ifdef NE_SANITY_CHECK
731retry:
732#endif
733
734#ifdef NE8390_RW_BUGFIX
735 /* Handle the read-before-write bug the same way as the
736 Crynwr packet driver -- the NatSemi method doesn't work.
737 Actually this doesn't always work either, but if you have
738 problems with your NEx000 this is better than nothing! */
739
740 outb_p(0x42, nic_base + EN0_RCNTLO);
741 outb_p(0x00, nic_base + EN0_RCNTHI);
742 outb_p(0x42, nic_base + EN0_RSARLO);
743 outb_p(0x00, nic_base + EN0_RSARHI);
744 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
745 /* Make certain that the dummy read has occurred. */
746 udelay(6);
747#endif
748
749 outb_p(ENISR_RDC, nic_base + EN0_ISR);
750
751 /* Now the normal output. */
752 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
753 outb_p(count >> 8, nic_base + EN0_RCNTHI);
754 outb_p(0x00, nic_base + EN0_RSARLO);
755 outb_p(start_page, nic_base + EN0_RSARHI);
756
757 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
758 if (ei_status.word16) {
759 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
760 } else {
761 outsb(NE_BASE + NE_DATAPORT, buf, count);
762 }
763
764 dma_start = jiffies;
765
766#ifdef NE_SANITY_CHECK
767 /* This was for the ALPHA version only, but enough people have
768 been encountering problems so it is still here. */
769
770 if (ei_debug > 1)
771 {
772 /* DMA termination address check... */
773 int addr, tries = 20;
774 do {
775 int high = inb_p(nic_base + EN0_RSARHI);
776 int low = inb_p(nic_base + EN0_RSARLO);
777 addr = (high << 8) + low;
778 if ((start_page << 8) + count == addr)
779 break;
780 } while (--tries > 0);
781
782 if (tries <= 0)
783 {
784 printk(KERN_WARNING "%s: Tx packet transfer address mismatch,"
785 "%#4.4x (expected) vs. %#4.4x (actual).\n",
786 dev->name, (start_page << 8) + count, addr);
787 if (retries++ == 0)
788 goto retry;
789 }
790 }
791#endif
792
793 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800794 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
796 ne_reset_8390(dev);
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200797 NS8390p_init(dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 break;
799 }
800
801 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
802 ei_status.dmaing &= ~0x01;
803 return;
804}
805
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900806static int __init ne_drv_probe(struct platform_device *pdev)
807{
808 struct net_device *dev;
809 struct resource *res;
810 int err, irq;
811
812 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
813 irq = platform_get_irq(pdev, 0);
814 if (!res || irq < 0)
815 return -ENODEV;
816
Alan Cox055e5112008-07-03 23:43:12 -0700817 dev = alloc_eip_netdev();
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900818 if (!dev)
819 return -ENOMEM;
820 dev->irq = irq;
821 dev->base_addr = res->start;
822 err = do_ne_probe(dev);
823 if (err) {
824 free_netdev(dev);
825 return err;
826 }
827 platform_set_drvdata(pdev, dev);
828 return 0;
829}
830
831static int __exit ne_drv_remove(struct platform_device *pdev)
832{
833 struct net_device *dev = platform_get_drvdata(pdev);
834
835 unregister_netdev(dev);
836 free_irq(dev->irq, dev);
837 release_region(dev->base_addr, NE_IO_EXTENT);
838 free_netdev(dev);
839 return 0;
840}
841
842#ifdef CONFIG_PM
843static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
844{
845 struct net_device *dev = platform_get_drvdata(pdev);
846
David Fries539b06f2008-09-08 22:01:14 -0500847 if (netif_running(dev)) {
848 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900849 netif_device_detach(dev);
David Fries539b06f2008-09-08 22:01:14 -0500850 if (idev)
851 pnp_stop_dev(idev);
852 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900853 return 0;
854}
855
856static int ne_drv_resume(struct platform_device *pdev)
857{
858 struct net_device *dev = platform_get_drvdata(pdev);
859
860 if (netif_running(dev)) {
David Fries539b06f2008-09-08 22:01:14 -0500861 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
862 if (idev)
863 pnp_start_dev(idev);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900864 ne_reset_8390(dev);
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200865 NS8390p_init(dev, 1);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900866 netif_device_attach(dev);
867 }
868 return 0;
869}
870#else
871#define ne_drv_suspend NULL
872#define ne_drv_resume NULL
873#endif
874
875static struct platform_driver ne_driver = {
876 .remove = __exit_p(ne_drv_remove),
877 .suspend = ne_drv_suspend,
878 .resume = ne_drv_resume,
879 .driver = {
880 .name = DRV_NAME,
881 .owner = THIS_MODULE,
882 },
883};
884
885static int __init ne_init(void)
886{
887 return platform_driver_probe(&ne_driver, ne_drv_probe);
888}
889
890static void __exit ne_exit(void)
891{
892 platform_driver_unregister(&ne_driver);
893}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400894
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895#ifdef MODULE
896#define MAX_NE_CARDS 4 /* Max number of NE cards per module */
897static struct net_device *dev_ne[MAX_NE_CARDS];
898static int io[MAX_NE_CARDS];
899static int irq[MAX_NE_CARDS];
900static int bad[MAX_NE_CARDS]; /* 0xbad = bad sig or no reset ack */
901
902module_param_array(io, int, NULL, 0);
903module_param_array(irq, int, NULL, 0);
904module_param_array(bad, int, NULL, 0);
905MODULE_PARM_DESC(io, "I/O base address(es),required");
906MODULE_PARM_DESC(irq, "IRQ number(s)");
907MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
908MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
909MODULE_LICENSE("GPL");
910
911/* This is set up so that no ISA autoprobe takes place. We can't guarantee
912that the ne2k probe is the last 8390 based probe to take place (as it
913is at boot) and so the probe will get confused by any other 8390 cards.
914ISA device autoprobes on a running machine are not recommended anyway. */
915
Randy.Dunlap5d1f16c2006-06-10 12:13:35 -0700916int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
918 int this_dev, found = 0;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900919 int plat_found = !ne_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
Alan Cox055e5112008-07-03 23:43:12 -0700922 struct net_device *dev = alloc_eip_netdev();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 if (!dev)
924 break;
925 dev->irq = irq[this_dev];
926 dev->mem_end = bad[this_dev];
927 dev->base_addr = io[this_dev];
928 if (do_ne_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400929 dev_ne[found++] = dev;
930 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 }
932 free_netdev(dev);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900933 if (found || plat_found)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 break;
935 if (io[this_dev] != 0)
936 printk(KERN_WARNING "ne.c: No NE*000 card found at i/o = %#x\n", io[this_dev]);
937 else
938 printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\" value(s) for ISA cards.\n");
939 return -ENXIO;
940 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900941 if (found || plat_found)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 return 0;
943 return -ENODEV;
944}
945
Denis Vlasenko64916f12006-01-05 22:45:47 -0800946static void cleanup_card(struct net_device *dev)
947{
948 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
949 if (idev)
950 pnp_device_detach(idev);
951 free_irq(dev->irq, dev);
952 release_region(dev->base_addr, NE_IO_EXTENT);
953}
954
Al Viroafc8eb42006-06-14 18:50:53 -0400955void __exit cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956{
957 int this_dev;
958
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900959 ne_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
961 struct net_device *dev = dev_ne[this_dev];
962 if (dev) {
963 unregister_netdev(dev);
964 cleanup_card(dev);
965 free_netdev(dev);
966 }
967 }
968}
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900969#else /* MODULE */
970module_init(ne_init);
971module_exit(ne_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972#endif /* MODULE */