blob: eb681c0d51ba1ef61b7537bd6974a9413eabf66e [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
David Friesfbb80232008-09-22 14:10:20 -070067/* 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
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
David Friesfbb80232008-09-22 14:10:20 -070096/* 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. */
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900100#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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105/* A zero-terminated list of I/O addresses to be probed at boot. */
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900106#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107static 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 */
Atsushi Nemotoc7e65c12008-08-08 00:55:17 +0900144#ifdef CONFIG_MACH_TX49XX
Ralf Baechle9cc975e2005-10-10 14:51:21 +0100145 {"RBHMA4X00-RTL8019", "RBHMA4X00/RTL8019", {0x00, 0x60, 0x0a}}, /* Toshiba built-in */
146#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 {"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
Olaf Hering44456d32005-07-27 11:45:17 -0700165#if defined(CONFIG_PLAT_MAPPI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166# define DCR_VAL 0x4b
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400167#elif defined(CONFIG_PLAT_OAKS32R) || \
Atsushi Nemotoc7e65c12008-08-08 00:55:17 +0900168 defined(CONFIG_MACH_TX49XX)
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400169# define DCR_VAL 0x48 /* 8-bit mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170#else
171# define DCR_VAL 0x49
172#endif
173
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900174static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175static int ne_probe_isapnp(struct net_device *dev);
176
177static int ne_open(struct net_device *dev);
178static int ne_close(struct net_device *dev);
179
180static void ne_reset_8390(struct net_device *dev);
181static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
182 int ring_page);
183static void ne_block_input(struct net_device *dev, int count,
184 struct sk_buff *skb, int ring_offset);
185static void ne_block_output(struct net_device *dev, const int count,
186 const unsigned char *buf, const int start_page);
187
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189/* Probe for various non-shared-memory ethercards.
190
191 NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
192 buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
193 the SAPROM, while other supposed NE2000 clones must be detected by their
194 SA prefix.
195
196 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
197 mode results in doubled values, which can be detected and compensated for.
198
199 The probe is also responsible for initializing the card and filling
200 in the 'dev' and 'ei_status' structures.
201
202 We use the minimum memory size for some ethercard product lines, iff we can't
203 distinguish models. You can increase the packet buffer size by setting
204 PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are:
205 E1010 starts at 0x100 and ends at 0x2000.
206 E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
207 E2010 starts at 0x100 and ends at 0x4000.
208 E2010-x starts at 0x100 and ends at 0xffff. */
209
210static int __init do_ne_probe(struct net_device *dev)
211{
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900212 unsigned long base_addr = dev->base_addr;
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900213#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 int orig_irq = dev->irq;
215#endif
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 /* First check any supplied i/o locations. User knows best. <cough> */
David Friesfbb80232008-09-22 14:10:20 -0700218 if (base_addr > 0x1ff) { /* Check a single specified location. */
219 int ret = ne_probe1(dev, base_addr);
220 if (ret)
221 printk(KERN_WARNING "ne.c: No NE*000 card found at "
222 "i/o = %#lx\n", base_addr);
223 return ret;
224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 else if (base_addr != 0) /* Don't probe at all. */
226 return -ENXIO;
227
228 /* Then look for any installed ISAPnP clones */
229 if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
230 return 0;
231
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900232#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 /* Last resort. The semi-risky ISA auto-probe. */
234 for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
235 int ioaddr = netcard_portlist[base_addr];
236 dev->irq = orig_irq;
237 if (ne_probe1(dev, ioaddr) == 0)
238 return 0;
239 }
240#endif
241
242 return -ENODEV;
243}
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245static int __init ne_probe_isapnp(struct net_device *dev)
246{
247 int i;
248
249 for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
250 struct pnp_dev *idev = NULL;
251
252 while ((idev = pnp_find_dev(NULL,
253 isapnp_clone_list[i].vendor,
254 isapnp_clone_list[i].function,
255 idev))) {
256 /* Avoid already found cards from previous calls */
257 if (pnp_device_attach(idev) < 0)
258 continue;
259 if (pnp_activate_dev(idev) < 0) {
260 pnp_device_detach(idev);
261 continue;
262 }
263 /* if no io and irq, search for next */
264 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
265 pnp_device_detach(idev);
266 continue;
267 }
268 /* found it */
269 dev->base_addr = pnp_port_start(idev, 0);
270 dev->irq = pnp_irq(idev, 0);
271 printk(KERN_INFO "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
272 (char *) isapnp_clone_list[i].driver_data,
273 dev->base_addr, dev->irq);
274 if (ne_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
275 printk(KERN_ERR "ne.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
276 pnp_device_detach(idev);
277 return -ENXIO;
278 }
279 ei_status.priv = (unsigned long)idev;
280 break;
281 }
282 if (!idev)
283 continue;
284 return 0;
285 }
286
287 return -ENODEV;
288}
289
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900290static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
292 int i;
293 unsigned char SA_prom[32];
294 int wordlength = 2;
295 const char *name = NULL;
296 int start_page, stop_page;
297 int neX000, ctron, copam, bad_card;
298 int reg0, ret;
299 static unsigned version_printed;
Joe Perches0795af52007-10-03 17:59:30 -0700300 DECLARE_MAC_BUF(mac);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
303 return -EBUSY;
304
305 reg0 = inb_p(ioaddr);
306 if (reg0 == 0xFF) {
307 ret = -ENODEV;
308 goto err_out;
309 }
310
311 /* Do a preliminary verification that we have a 8390. */
312 {
313 int regd;
314 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
315 regd = inb_p(ioaddr + 0x0d);
316 outb_p(0xff, ioaddr + 0x0d);
317 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
318 inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
319 if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
320 outb_p(reg0, ioaddr);
321 outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */
322 ret = -ENODEV;
323 goto err_out;
324 }
325 }
326
327 if (ei_debug && version_printed++ == 0)
328 printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2);
329
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900330 printk(KERN_INFO "NE*000 ethercard probe at %#3lx:", ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
332 /* A user with a poor card that fails to ack the reset, or that
333 does not have a valid 0x57,0x57 signature can still use this
334 without having to recompile. Specifying an i/o address along
335 with an otherwise unused dev->mem_end value of "0xBAD" will
336 cause the driver to skip these parts of the probe. */
337
David Friesfbb80232008-09-22 14:10:20 -0700338 bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340 /* Reset card. Who knows what dain-bramaged state it was left in. */
341
342 {
343 unsigned long reset_start_time = jiffies;
344
345 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
346 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
347
348 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800349 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 if (bad_card) {
351 printk(" (warning: no reset ack)");
352 break;
353 } else {
354 printk(" not found (no reset ack).\n");
355 ret = -ENODEV;
356 goto err_out;
357 }
358 }
359
360 outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
361 }
362
363 /* Read the 16 bytes of station address PROM.
Ingo Molnarf0084a32008-07-22 09:23:34 +0200364 We must first initialize registers, similar to NS8390p_init(eifdev, 0).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 We can't reliably read the SAPROM address without this.
366 (I learned the hard way!). */
367 {
368 struct {unsigned char value, offset; } program_seq[] =
369 {
370 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
371 {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
372 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
373 {0x00, EN0_RCNTHI},
374 {0x00, EN0_IMR}, /* Mask completion irq. */
375 {0xFF, EN0_ISR},
376 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
377 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
378 {32, EN0_RCNTLO},
379 {0x00, EN0_RCNTHI},
380 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
381 {0x00, EN0_RSARHI},
382 {E8390_RREAD+E8390_START, E8390_CMD},
383 };
384
Denis Chengff8ac602007-09-02 18:30:18 +0800385 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
387
388 }
389 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
390 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
391 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
392 if (SA_prom[i] != SA_prom[i+1])
393 wordlength = 1;
394 }
395
396 if (wordlength == 2)
397 {
398 for (i = 0; i < 16; i++)
399 SA_prom[i] = SA_prom[i+i];
400 /* We must set the 8390 for word mode. */
401 outb_p(DCR_VAL, ioaddr + EN0_DCFG);
402 start_page = NESM_START_PG;
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400403
404 /*
405 * Realtek RTL8019AS datasheet says that the PSTOP register
406 * shouldn't exceed 0x60 in 8-bit mode.
407 * This chip can be identified by reading the signature from
408 * the remote byte count registers (otherwise write-only)...
409 */
410 if ((DCR_VAL & 0x01) == 0 && /* 8-bit mode */
411 inb(ioaddr + EN0_RCNTLO) == 0x50 &&
412 inb(ioaddr + EN0_RCNTHI) == 0x70)
413 stop_page = 0x60;
414 else
415 stop_page = NESM_STOP_PG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 } else {
417 start_page = NE1SM_START_PG;
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400418 stop_page = NE1SM_STOP_PG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
420
421#if defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
422 neX000 = ((SA_prom[14] == 0x57 && SA_prom[15] == 0x57)
423 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
424#else
425 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
426#endif
427 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
428 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
429
430 /* Set up the rest of the parameters. */
431 if (neX000 || bad_card || copam) {
432 name = (wordlength == 2) ? "NE2000" : "NE1000";
433 }
434 else if (ctron)
435 {
436 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
437 start_page = 0x01;
438 stop_page = (wordlength == 2) ? 0x40 : 0x20;
439 }
440 else
441 {
442#ifdef SUPPORT_NE_BAD_CLONES
443 /* Ack! Well, there might be a *bad* NE*000 clone there.
444 Check for total bogus addresses. */
445 for (i = 0; bad_clone_list[i].name8; i++)
446 {
447 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
448 SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
449 SA_prom[2] == bad_clone_list[i].SAprefix[2])
450 {
451 if (wordlength == 2)
452 {
453 name = bad_clone_list[i].name16;
454 } else {
455 name = bad_clone_list[i].name8;
456 }
457 break;
458 }
459 }
460 if (bad_clone_list[i].name8 == NULL)
461 {
462 printk(" not found (invalid signature %2.2x %2.2x).\n",
463 SA_prom[14], SA_prom[15]);
464 ret = -ENXIO;
465 goto err_out;
466 }
467#else
468 printk(" not found.\n");
469 ret = -ENXIO;
470 goto err_out;
471#endif
472 }
473
474 if (dev->irq < 2)
475 {
476 unsigned long cookie = probe_irq_on();
477 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */
478 outb_p(0x00, ioaddr + EN0_RCNTLO);
479 outb_p(0x00, ioaddr + EN0_RCNTHI);
480 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
481 mdelay(10); /* wait 10ms for interrupt to propagate */
482 outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */
483 dev->irq = probe_irq_off(cookie);
484 if (ei_debug > 2)
485 printk(" autoirq is %d\n", dev->irq);
486 } else if (dev->irq == 2)
487 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
488 or don't know which one to set. */
489 dev->irq = 9;
490
491 if (! dev->irq) {
492 printk(" failed to detect IRQ line.\n");
493 ret = -EAGAIN;
494 goto err_out;
495 }
496
497 /* Snarf the interrupt now. There's no point in waiting since we cannot
498 share and the board will usually be enabled. */
Alan Cox055e5112008-07-03 23:43:12 -0700499 ret = request_irq(dev->irq, eip_interrupt, 0, name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 if (ret) {
501 printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
502 goto err_out;
503 }
504
505 dev->base_addr = ioaddr;
506
507#ifdef CONFIG_PLAT_MAPPI
508 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
509 ioaddr + E8390_CMD); /* 0x61 */
510 for (i = 0 ; i < ETHER_ADDR_LEN ; i++) {
511 dev->dev_addr[i] = SA_prom[i]
512 = inb_p(ioaddr + EN1_PHYS_SHIFT(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
514#else
515 for(i = 0; i < ETHER_ADDR_LEN; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 dev->dev_addr[i] = SA_prom[i];
517 }
518#endif
519
Joe Perches0795af52007-10-03 17:59:30 -0700520 printk("%s\n", print_mac(mac, dev->dev_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
522 ei_status.name = name;
523 ei_status.tx_start_page = start_page;
524 ei_status.stop_page = stop_page;
Ralf Baechle9cc975e2005-10-10 14:51:21 +0100525
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400526 /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
527 ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 ei_status.rx_start_page = start_page + TX_PAGES;
530#ifdef PACKETBUF_MEMSIZE
531 /* Allow the packet buffer size to be overridden by know-it-alls. */
532 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
533#endif
534
535 ei_status.reset_8390 = &ne_reset_8390;
536 ei_status.block_input = &ne_block_input;
537 ei_status.block_output = &ne_block_output;
538 ei_status.get_8390_hdr = &ne_get_8390_hdr;
539 ei_status.priv = 0;
540 dev->open = &ne_open;
541 dev->stop = &ne_close;
542#ifdef CONFIG_NET_POLL_CONTROLLER
Alan Cox055e5112008-07-03 23:43:12 -0700543 dev->poll_controller = eip_poll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544#endif
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200545 NS8390p_init(dev, 0);
b1fc5502005-05-12 20:11:55 -0400546
547 ret = register_netdev(dev);
548 if (ret)
549 goto out_irq;
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900550 printk(KERN_INFO "%s: %s found at %#lx, using IRQ %d.\n",
551 dev->name, name, ioaddr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 return 0;
553
b1fc5502005-05-12 20:11:55 -0400554out_irq:
555 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556err_out:
557 release_region(ioaddr, NE_IO_EXTENT);
558 return ret;
559}
560
561static int ne_open(struct net_device *dev)
562{
Alan Cox055e5112008-07-03 23:43:12 -0700563 eip_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 return 0;
565}
566
567static int ne_close(struct net_device *dev)
568{
569 if (ei_debug > 1)
570 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
Alan Cox055e5112008-07-03 23:43:12 -0700571 eip_close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 return 0;
573}
574
575/* Hard reset the card. This used to pause for the same period that a
576 8390 reset command required, but that shouldn't be necessary. */
577
578static void ne_reset_8390(struct net_device *dev)
579{
580 unsigned long reset_start_time = jiffies;
581
582 if (ei_debug > 1)
583 printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
584
585 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
586 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
587
588 ei_status.txing = 0;
589 ei_status.dmaing = 0;
590
591 /* This check _should_not_ be necessary, omit eventually. */
592 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800593 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", dev->name);
595 break;
596 }
597 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
598}
599
600/* Grab the 8390 specific header. Similar to the block_input routine, but
601 we don't need to be concerned with ring wrap as the header will be at
602 the start of a page, so we optimize accordingly. */
603
604static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
605{
606 int nic_base = dev->base_addr;
607
608 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
609
610 if (ei_status.dmaing)
611 {
612 printk(KERN_EMERG "%s: DMAing conflict in ne_get_8390_hdr "
613 "[DMAstat:%d][irqlock:%d].\n",
614 dev->name, ei_status.dmaing, ei_status.irqlock);
615 return;
616 }
617
618 ei_status.dmaing |= 0x01;
619 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
620 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
621 outb_p(0, nic_base + EN0_RCNTHI);
622 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
623 outb_p(ring_page, nic_base + EN0_RSARHI);
624 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
625
626 if (ei_status.word16)
627 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
628 else
629 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
630
631 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
632 ei_status.dmaing &= ~0x01;
633
634 le16_to_cpus(&hdr->count);
635}
636
637/* Block input and output, similar to the Crynwr packet driver. If you
638 are porting to a new ethercard, look at the packet driver source for hints.
639 The NEx000 doesn't share the on-board packet memory -- you have to put
640 the packet out through the "remote DMA" dataport using outb. */
641
642static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
643{
644#ifdef NE_SANITY_CHECK
645 int xfer_count = count;
646#endif
647 int nic_base = dev->base_addr;
648 char *buf = skb->data;
649
650 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
651 if (ei_status.dmaing)
652 {
653 printk(KERN_EMERG "%s: DMAing conflict in ne_block_input "
654 "[DMAstat:%d][irqlock:%d].\n",
655 dev->name, ei_status.dmaing, ei_status.irqlock);
656 return;
657 }
658 ei_status.dmaing |= 0x01;
659 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
660 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
661 outb_p(count >> 8, nic_base + EN0_RCNTHI);
662 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
663 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
664 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
665 if (ei_status.word16)
666 {
667 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
668 if (count & 0x01)
669 {
670 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
671#ifdef NE_SANITY_CHECK
672 xfer_count++;
673#endif
674 }
675 } else {
676 insb(NE_BASE + NE_DATAPORT, buf, count);
677 }
678
679#ifdef NE_SANITY_CHECK
680 /* This was for the ALPHA version only, but enough people have
681 been encountering problems so it is still here. If you see
682 this message you either 1) have a slightly incompatible clone
683 or 2) have noise/speed problems with your bus. */
684
685 if (ei_debug > 1)
686 {
687 /* DMA termination address check... */
688 int addr, tries = 20;
689 do {
690 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
691 -- it's broken for Rx on some cards! */
692 int high = inb_p(nic_base + EN0_RSARHI);
693 int low = inb_p(nic_base + EN0_RSARLO);
694 addr = (high << 8) + low;
695 if (((ring_offset + xfer_count) & 0xff) == low)
696 break;
697 } while (--tries > 0);
698 if (tries <= 0)
699 printk(KERN_WARNING "%s: RX transfer address mismatch,"
700 "%#4.4x (expected) vs. %#4.4x (actual).\n",
701 dev->name, ring_offset + xfer_count, addr);
702 }
703#endif
704 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
705 ei_status.dmaing &= ~0x01;
706}
707
708static void ne_block_output(struct net_device *dev, int count,
709 const unsigned char *buf, const int start_page)
710{
711 int nic_base = NE_BASE;
712 unsigned long dma_start;
713#ifdef NE_SANITY_CHECK
714 int retries = 0;
715#endif
716
717 /* Round the count up for word writes. Do we need to do this?
718 What effect will an odd byte count have on the 8390?
719 I should check someday. */
720
721 if (ei_status.word16 && (count & 0x01))
722 count++;
723
724 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
725 if (ei_status.dmaing)
726 {
727 printk(KERN_EMERG "%s: DMAing conflict in ne_block_output."
728 "[DMAstat:%d][irqlock:%d]\n",
729 dev->name, ei_status.dmaing, ei_status.irqlock);
730 return;
731 }
732 ei_status.dmaing |= 0x01;
733 /* We should already be in page 0, but to be safe... */
734 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
735
736#ifdef NE_SANITY_CHECK
737retry:
738#endif
739
740#ifdef NE8390_RW_BUGFIX
741 /* Handle the read-before-write bug the same way as the
742 Crynwr packet driver -- the NatSemi method doesn't work.
743 Actually this doesn't always work either, but if you have
744 problems with your NEx000 this is better than nothing! */
745
746 outb_p(0x42, nic_base + EN0_RCNTLO);
747 outb_p(0x00, nic_base + EN0_RCNTHI);
748 outb_p(0x42, nic_base + EN0_RSARLO);
749 outb_p(0x00, nic_base + EN0_RSARHI);
750 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
751 /* Make certain that the dummy read has occurred. */
752 udelay(6);
753#endif
754
755 outb_p(ENISR_RDC, nic_base + EN0_ISR);
756
757 /* Now the normal output. */
758 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
759 outb_p(count >> 8, nic_base + EN0_RCNTHI);
760 outb_p(0x00, nic_base + EN0_RSARLO);
761 outb_p(start_page, nic_base + EN0_RSARHI);
762
763 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
764 if (ei_status.word16) {
765 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
766 } else {
767 outsb(NE_BASE + NE_DATAPORT, buf, count);
768 }
769
770 dma_start = jiffies;
771
772#ifdef NE_SANITY_CHECK
773 /* This was for the ALPHA version only, but enough people have
774 been encountering problems so it is still here. */
775
776 if (ei_debug > 1)
777 {
778 /* DMA termination address check... */
779 int addr, tries = 20;
780 do {
781 int high = inb_p(nic_base + EN0_RSARHI);
782 int low = inb_p(nic_base + EN0_RSARLO);
783 addr = (high << 8) + low;
784 if ((start_page << 8) + count == addr)
785 break;
786 } while (--tries > 0);
787
788 if (tries <= 0)
789 {
790 printk(KERN_WARNING "%s: Tx packet transfer address mismatch,"
791 "%#4.4x (expected) vs. %#4.4x (actual).\n",
792 dev->name, (start_page << 8) + count, addr);
793 if (retries++ == 0)
794 goto retry;
795 }
796 }
797#endif
798
799 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800800 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
802 ne_reset_8390(dev);
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200803 NS8390p_init(dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 break;
805 }
806
807 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
808 ei_status.dmaing &= ~0x01;
809 return;
810}
811
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900812static int __init ne_drv_probe(struct platform_device *pdev)
813{
814 struct net_device *dev;
David Friesfbb80232008-09-22 14:10:20 -0700815 int err, this_dev = pdev->id;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900816 struct resource *res;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900817
Alan Cox055e5112008-07-03 23:43:12 -0700818 dev = alloc_eip_netdev();
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900819 if (!dev)
820 return -ENOMEM;
David Friesfbb80232008-09-22 14:10:20 -0700821
822 /* ne.c doesn't populate resources in platform_device, but
823 * rbtx4927_ne_init and rbtx4938_ne_init do register devices
824 * with resources.
825 */
826 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
827 if (res) {
828 dev->base_addr = res->start;
829 dev->irq = platform_get_irq(pdev, 0);
830 } else {
831 if (this_dev < 0 || this_dev >= MAX_NE_CARDS)
832 return -EINVAL;
833 dev->base_addr = io[this_dev];
834 dev->irq = irq[this_dev];
835 dev->mem_end = bad[this_dev];
836 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900837 err = do_ne_probe(dev);
838 if (err) {
839 free_netdev(dev);
840 return err;
841 }
842 platform_set_drvdata(pdev, dev);
David Friesfbb80232008-09-22 14:10:20 -0700843
844 /* Update with any values found by probing, don't update if
845 * resources were specified.
846 */
847 if (!res) {
848 io[this_dev] = dev->base_addr;
849 irq[this_dev] = dev->irq;
850 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900851 return 0;
852}
853
David Friesfbb80232008-09-22 14:10:20 -0700854static int ne_drv_remove(struct platform_device *pdev)
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900855{
856 struct net_device *dev = platform_get_drvdata(pdev);
857
David Friesfbb80232008-09-22 14:10:20 -0700858 if (dev) {
859 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
860 netif_device_detach(dev);
861 unregister_netdev(dev);
862 if (idev)
863 pnp_device_detach(idev);
864 /* Careful ne_drv_remove can be called twice, once from
865 * the platform_driver.remove and again when the
866 * platform_device is being removed.
867 */
868 ei_status.priv = 0;
869 free_irq(dev->irq, dev);
870 release_region(dev->base_addr, NE_IO_EXTENT);
871 free_netdev(dev);
872 platform_set_drvdata(pdev, NULL);
873 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900874 return 0;
875}
876
David Friesfbb80232008-09-22 14:10:20 -0700877/* Remove unused devices or all if true. */
878static void ne_loop_rm_unreg(int all)
879{
880 int this_dev;
881 struct platform_device *pdev;
882 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
883 pdev = pdev_ne[this_dev];
884 /* No network device == unused */
885 if (pdev && (!platform_get_drvdata(pdev) || all)) {
886 ne_drv_remove(pdev);
887 platform_device_unregister(pdev);
888 pdev_ne[this_dev] = NULL;
889 }
890 }
891}
892
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900893#ifdef CONFIG_PM
894static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
895{
896 struct net_device *dev = platform_get_drvdata(pdev);
897
David Fries539b06f2008-09-08 22:01:14 -0500898 if (netif_running(dev)) {
899 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900900 netif_device_detach(dev);
David Fries539b06f2008-09-08 22:01:14 -0500901 if (idev)
902 pnp_stop_dev(idev);
903 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900904 return 0;
905}
906
907static int ne_drv_resume(struct platform_device *pdev)
908{
909 struct net_device *dev = platform_get_drvdata(pdev);
910
911 if (netif_running(dev)) {
David Fries539b06f2008-09-08 22:01:14 -0500912 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
913 if (idev)
914 pnp_start_dev(idev);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900915 ne_reset_8390(dev);
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200916 NS8390p_init(dev, 1);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900917 netif_device_attach(dev);
918 }
919 return 0;
920}
921#else
922#define ne_drv_suspend NULL
923#define ne_drv_resume NULL
924#endif
925
926static struct platform_driver ne_driver = {
David Friesfbb80232008-09-22 14:10:20 -0700927 .remove = ne_drv_remove,
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900928 .suspend = ne_drv_suspend,
929 .resume = ne_drv_resume,
930 .driver = {
931 .name = DRV_NAME,
932 .owner = THIS_MODULE,
933 },
934};
935
David Friesfbb80232008-09-22 14:10:20 -0700936static void __init ne_add_devices(void)
937{
938 int this_dev;
939 struct platform_device *pdev;
940
941 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
942 if (pdev_ne[this_dev])
943 continue;
944 pdev = platform_device_register_simple(
945 DRV_NAME, this_dev, NULL, 0);
946 if (IS_ERR(pdev))
947 continue;
948 pdev_ne[this_dev] = pdev;
949 }
950}
951
952#ifdef MODULE
953int __init init_module()
954{
955 int retval;
956 ne_add_devices();
957 retval = platform_driver_probe(&ne_driver, ne_drv_probe);
958 if (retval) {
959 if (io[0] == 0)
960 printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\""
961 " value(s) for ISA cards.\n");
962 ne_loop_rm_unreg(1);
963 return retval;
964 }
965
966 /* Unregister unused platform_devices. */
967 ne_loop_rm_unreg(0);
968 return retval;
969}
970#else /* MODULE */
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900971static int __init ne_init(void)
972{
David Friesfbb80232008-09-22 14:10:20 -0700973 int retval = platform_driver_probe(&ne_driver, ne_drv_probe);
974
975 /* Unregister unused platform_devices. */
976 ne_loop_rm_unreg(0);
977 return retval;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900978}
David Friesfbb80232008-09-22 14:10:20 -0700979module_init(ne_init);
980
981struct net_device * __init ne_probe(int unit)
982{
983 int this_dev;
984 struct net_device *dev;
985
986 /* Find an empty slot, that is no net_device and zero io port. */
987 this_dev = 0;
988 while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) ||
989 io[this_dev]) {
990 if (++this_dev == MAX_NE_CARDS)
991 return ERR_PTR(-ENOMEM);
992 }
993
994 /* Get irq, io from kernel command line */
995 dev = alloc_eip_netdev();
996 if (!dev)
997 return ERR_PTR(-ENOMEM);
998
999 sprintf(dev->name, "eth%d", unit);
1000 netdev_boot_setup_check(dev);
1001
1002 io[this_dev] = dev->base_addr;
1003 irq[this_dev] = dev->irq;
1004 bad[this_dev] = dev->mem_end;
1005
1006 free_netdev(dev);
1007
1008 ne_add_devices();
1009
1010 /* return the first device found */
1011 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
1012 if (pdev_ne[this_dev]) {
1013 dev = platform_get_drvdata(pdev_ne[this_dev]);
1014 if (dev)
1015 return dev;
1016 }
1017 }
1018
1019 return ERR_PTR(-ENODEV);
1020}
1021#endif /* MODULE */
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +09001022
1023static void __exit ne_exit(void)
1024{
1025 platform_driver_unregister(&ne_driver);
David Friesfbb80232008-09-22 14:10:20 -07001026 ne_loop_rm_unreg(1);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +09001027}
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +09001028module_exit(ne_exit);