blob: 58eaa8f34942cac2dfe416e0d6086b7103afb83c [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <asm/io.h>
57
58#include "8390.h"
59
60#define DRV_NAME "ne"
61
62/* Some defines that people can play with if so inclined. */
63
64/* Do we support clones that don't adhere to 14,15 of the SAprom ? */
65#define SUPPORT_NE_BAD_CLONES
David Friesfbb80232008-09-22 14:10:20 -070066/* 0xbad = bad sig or no reset ack */
67#define BAD 0xbad
68
69#define MAX_NE_CARDS 4 /* Max number of NE cards per module */
70static struct platform_device *pdev_ne[MAX_NE_CARDS];
71static int io[MAX_NE_CARDS];
72static int irq[MAX_NE_CARDS];
73static int bad[MAX_NE_CARDS];
Matthew Whiteheadc45f8122013-12-11 17:00:59 -050074static u32 ne_msg_enable;
David Friesfbb80232008-09-22 14:10:20 -070075
76#ifdef MODULE
77module_param_array(io, int, NULL, 0);
78module_param_array(irq, int, NULL, 0);
79module_param_array(bad, int, NULL, 0);
Matthew Whiteheadc45f8122013-12-11 17:00:59 -050080module_param_named(msg_enable, ne_msg_enable, uint, (S_IRUSR|S_IRGRP|S_IROTH));
David Friesfbb80232008-09-22 14:10:20 -070081MODULE_PARM_DESC(io, "I/O base address(es),required");
82MODULE_PARM_DESC(irq, "IRQ number(s)");
83MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
Matthew Whiteheadc45f8122013-12-11 17:00:59 -050084MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
David Friesfbb80232008-09-22 14:10:20 -070085MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
86MODULE_LICENSE("GPL");
87#endif /* MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89/* Do we perform extra sanity checks on stuff ? */
90/* #define NE_SANITY_CHECK */
91
92/* Do we implement the read before write bugfix ? */
93/* #define NE_RW_BUGFIX */
94
95/* Do we have a non std. amount of memory? (in units of 256 byte pages) */
96/* #define PACKETBUF_MEMSIZE 0x40 */
97
David Friesfbb80232008-09-22 14:10:20 -070098/* This is set up so that no ISA autoprobe takes place. We can't guarantee
99that the ne2k probe is the last 8390 based probe to take place (as it
100is at boot) and so the probe will get confused by any other 8390 cards.
101ISA device autoprobes on a running machine are not recommended anyway. */
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900102#if !defined(MODULE) && (defined(CONFIG_ISA) || defined(CONFIG_M32R))
103/* Do we need a portlist for the ISA auto-probe ? */
104#define NEEDS_PORTLIST
105#endif
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107/* A zero-terminated list of I/O addresses to be probed at boot. */
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900108#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109static unsigned int netcard_portlist[] __initdata = {
110 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
111};
112#endif
113
114static struct isapnp_device_id isapnp_clone_list[] __initdata = {
115 { ISAPNP_CARD_ID('A','X','E',0x2011),
116 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011),
117 (long) "NetGear EA201" },
118 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
119 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216),
120 (long) "NN NE2000" },
121 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
122 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6),
123 (long) "Generic PNP" },
124 { } /* terminate list */
125};
126
127MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
128
129#ifdef SUPPORT_NE_BAD_CLONES
130/* A list of bad clones that we none-the-less recognize. */
131static struct { const char *name8, *name16; unsigned char SAprefix[4];}
132bad_clone_list[] __initdata = {
133 {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
134 {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
135 {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */
136 {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
137 {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
138 {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
139 {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */
140 {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
141 {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */
142 {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */
143 {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
144 {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */
145 {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */
Atsushi Nemotoc7e65c12008-08-08 00:55:17 +0900146#ifdef CONFIG_MACH_TX49XX
Atsushi Nemotoc5e49fb2010-03-16 05:27:40 +0000147 {"RBHMA4X00-RTL8019", "RBHMA4X00-RTL8019", {0x00, 0x60, 0x0a}}, /* Toshiba built-in */
Ralf Baechle9cc975e2005-10-10 14:51:21 +0100148#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
150 {NULL,}
151};
152#endif
153
154/* ---- No user-serviceable parts below ---- */
155
156#define NE_BASE (dev->base_addr)
157#define NE_CMD 0x00
158#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
159#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
160#define NE_IO_EXTENT 0x20
161
162#define NE1SM_START_PG 0x20 /* First page of TX buffer */
163#define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
164#define NESM_START_PG 0x40 /* First page of TX buffer */
165#define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
166
Olaf Hering44456d32005-07-27 11:45:17 -0700167#if defined(CONFIG_PLAT_MAPPI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168# define DCR_VAL 0x4b
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400169#elif defined(CONFIG_PLAT_OAKS32R) || \
Atsushi Nemotoc7e65c12008-08-08 00:55:17 +0900170 defined(CONFIG_MACH_TX49XX)
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400171# define DCR_VAL 0x48 /* 8-bit mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172#else
173# define DCR_VAL 0x49
174#endif
175
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900176static int ne_probe1(struct net_device *dev, unsigned long ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177static int ne_probe_isapnp(struct net_device *dev);
178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179static void ne_reset_8390(struct net_device *dev);
180static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
181 int ring_page);
182static void ne_block_input(struct net_device *dev, int count,
183 struct sk_buff *skb, int ring_offset);
184static void ne_block_output(struct net_device *dev, const int count,
185 const unsigned char *buf, const int start_page);
186
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/* Probe for various non-shared-memory ethercards.
189
190 NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
191 buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
192 the SAPROM, while other supposed NE2000 clones must be detected by their
193 SA prefix.
194
195 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
196 mode results in doubled values, which can be detected and compensated for.
197
198 The probe is also responsible for initializing the card and filling
199 in the 'dev' and 'ei_status' structures.
200
201 We use the minimum memory size for some ethercard product lines, iff we can't
202 distinguish models. You can increase the packet buffer size by setting
203 PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are:
204 E1010 starts at 0x100 and ends at 0x2000.
205 E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
206 E2010 starts at 0x100 and ends at 0x4000.
207 E2010-x starts at 0x100 and ends at 0xffff. */
208
209static int __init do_ne_probe(struct net_device *dev)
210{
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900211 unsigned long base_addr = dev->base_addr;
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900212#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 int orig_irq = dev->irq;
214#endif
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 /* First check any supplied i/o locations. User knows best. <cough> */
David Friesfbb80232008-09-22 14:10:20 -0700217 if (base_addr > 0x1ff) { /* Check a single specified location. */
218 int ret = ne_probe1(dev, base_addr);
219 if (ret)
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500220 netdev_warn(dev, "ne.c: No NE*000 card found at "
221 "i/o = %#lx\n", base_addr);
David Friesfbb80232008-09-22 14:10:20 -0700222 return ret;
223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 else if (base_addr != 0) /* Don't probe at all. */
225 return -ENXIO;
226
227 /* Then look for any installed ISAPnP clones */
228 if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
229 return 0;
230
Atsushi Nemoto1c08bf12007-05-01 00:27:49 +0900231#ifdef NEEDS_PORTLIST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 /* Last resort. The semi-risky ISA auto-probe. */
233 for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
234 int ioaddr = netcard_portlist[base_addr];
235 dev->irq = orig_irq;
236 if (ne_probe1(dev, ioaddr) == 0)
237 return 0;
238 }
239#endif
240
241 return -ENODEV;
242}
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244static int __init ne_probe_isapnp(struct net_device *dev)
245{
246 int i;
247
248 for (i = 0; isapnp_clone_list[i].vendor != 0; i++) {
249 struct pnp_dev *idev = NULL;
250
251 while ((idev = pnp_find_dev(NULL,
252 isapnp_clone_list[i].vendor,
253 isapnp_clone_list[i].function,
254 idev))) {
255 /* Avoid already found cards from previous calls */
256 if (pnp_device_attach(idev) < 0)
257 continue;
258 if (pnp_activate_dev(idev) < 0) {
259 pnp_device_detach(idev);
260 continue;
261 }
262 /* if no io and irq, search for next */
263 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
264 pnp_device_detach(idev);
265 continue;
266 }
267 /* found it */
268 dev->base_addr = pnp_port_start(idev, 0);
269 dev->irq = pnp_irq(idev, 0);
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500270 netdev_info(dev,
271 "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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 if (ne_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500275 netdev_err(dev,
276 "ne.c: Probe of ISAPnP card at %#lx failed.\n",
277 dev->base_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 pnp_device_detach(idev);
279 return -ENXIO;
280 }
281 ei_status.priv = (unsigned long)idev;
282 break;
283 }
284 if (!idev)
285 continue;
286 return 0;
287 }
288
289 return -ENODEV;
290}
291
Atsushi Nemotof0e93c12007-05-01 00:27:39 +0900292static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
294 int i;
295 unsigned char SA_prom[32];
296 int wordlength = 2;
297 const char *name = NULL;
298 int start_page, stop_page;
299 int neX000, ctron, copam, bad_card;
300 int reg0, ret;
301 static unsigned version_printed;
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500302 struct ei_device *ei_local = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
305 return -EBUSY;
306
307 reg0 = inb_p(ioaddr);
308 if (reg0 == 0xFF) {
309 ret = -ENODEV;
310 goto err_out;
311 }
312
313 /* Do a preliminary verification that we have a 8390. */
314 {
315 int regd;
316 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
317 regd = inb_p(ioaddr + 0x0d);
318 outb_p(0xff, ioaddr + 0x0d);
319 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
320 inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
321 if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
322 outb_p(reg0, ioaddr);
323 outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */
324 ret = -ENODEV;
325 goto err_out;
326 }
327 }
328
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500329 if ((ne_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
330 netdev_info(dev, "%s%s", version1, version2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500332 netdev_info(dev, "NE*000 ethercard probe at %#3lx:", ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 /* A user with a poor card that fails to ack the reset, or that
335 does not have a valid 0x57,0x57 signature can still use this
336 without having to recompile. Specifying an i/o address along
337 with an otherwise unused dev->mem_end value of "0xBAD" will
338 cause the driver to skip these parts of the probe. */
339
David Friesfbb80232008-09-22 14:10:20 -0700340 bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342 /* Reset card. Who knows what dain-bramaged state it was left in. */
343
344 {
345 unsigned long reset_start_time = jiffies;
346
347 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
348 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
349
350 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800351 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (bad_card) {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500353 pr_cont(" (warning: no reset ack)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 break;
355 } else {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500356 pr_cont(" not found (no reset ack).\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 ret = -ENODEV;
358 goto err_out;
359 }
360 }
361
362 outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
363 }
364
365 /* Read the 16 bytes of station address PROM.
Ingo Molnarf0084a32008-07-22 09:23:34 +0200366 We must first initialize registers, similar to NS8390p_init(eifdev, 0).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 We can't reliably read the SAPROM address without this.
368 (I learned the hard way!). */
369 {
370 struct {unsigned char value, offset; } program_seq[] =
371 {
372 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
373 {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
374 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
375 {0x00, EN0_RCNTHI},
376 {0x00, EN0_IMR}, /* Mask completion irq. */
377 {0xFF, EN0_ISR},
378 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
379 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
380 {32, EN0_RCNTLO},
381 {0x00, EN0_RCNTHI},
382 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
383 {0x00, EN0_RSARHI},
384 {E8390_RREAD+E8390_START, E8390_CMD},
385 };
386
Denis Chengff8ac602007-09-02 18:30:18 +0800387 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
389
390 }
391 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
392 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
393 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
394 if (SA_prom[i] != SA_prom[i+1])
395 wordlength = 1;
396 }
397
398 if (wordlength == 2)
399 {
400 for (i = 0; i < 16; i++)
401 SA_prom[i] = SA_prom[i+i];
402 /* We must set the 8390 for word mode. */
403 outb_p(DCR_VAL, ioaddr + EN0_DCFG);
404 start_page = NESM_START_PG;
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400405
406 /*
407 * Realtek RTL8019AS datasheet says that the PSTOP register
408 * shouldn't exceed 0x60 in 8-bit mode.
409 * This chip can be identified by reading the signature from
410 * the remote byte count registers (otherwise write-only)...
411 */
412 if ((DCR_VAL & 0x01) == 0 && /* 8-bit mode */
413 inb(ioaddr + EN0_RCNTLO) == 0x50 &&
414 inb(ioaddr + EN0_RCNTHI) == 0x70)
415 stop_page = 0x60;
416 else
417 stop_page = NESM_STOP_PG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 } else {
419 start_page = NE1SM_START_PG;
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400420 stop_page = NE1SM_STOP_PG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
422
423#if defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
424 neX000 = ((SA_prom[14] == 0x57 && SA_prom[15] == 0x57)
425 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
426#else
427 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
428#endif
429 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
430 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
431
432 /* Set up the rest of the parameters. */
433 if (neX000 || bad_card || copam) {
434 name = (wordlength == 2) ? "NE2000" : "NE1000";
435 }
436 else if (ctron)
437 {
438 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
439 start_page = 0x01;
440 stop_page = (wordlength == 2) ? 0x40 : 0x20;
441 }
442 else
443 {
444#ifdef SUPPORT_NE_BAD_CLONES
445 /* Ack! Well, there might be a *bad* NE*000 clone there.
446 Check for total bogus addresses. */
447 for (i = 0; bad_clone_list[i].name8; i++)
448 {
449 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
450 SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
451 SA_prom[2] == bad_clone_list[i].SAprefix[2])
452 {
453 if (wordlength == 2)
454 {
455 name = bad_clone_list[i].name16;
456 } else {
457 name = bad_clone_list[i].name8;
458 }
459 break;
460 }
461 }
462 if (bad_clone_list[i].name8 == NULL)
463 {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500464 pr_cont(" not found (invalid signature %2.2x %2.2x).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 SA_prom[14], SA_prom[15]);
466 ret = -ENXIO;
467 goto err_out;
468 }
469#else
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500470 pr_cont(" not found.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 ret = -ENXIO;
472 goto err_out;
473#endif
474 }
475
476 if (dev->irq < 2)
477 {
478 unsigned long cookie = probe_irq_on();
479 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */
480 outb_p(0x00, ioaddr + EN0_RCNTLO);
481 outb_p(0x00, ioaddr + EN0_RCNTHI);
482 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
483 mdelay(10); /* wait 10ms for interrupt to propagate */
484 outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */
485 dev->irq = probe_irq_off(cookie);
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500486 if (netif_msg_probe(ei_local))
487 pr_cont(" autoirq is %d", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 } else if (dev->irq == 2)
489 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
490 or don't know which one to set. */
491 dev->irq = 9;
492
493 if (! dev->irq) {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500494 pr_cont(" failed to detect IRQ line.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 ret = -EAGAIN;
496 goto err_out;
497 }
498
499 /* Snarf the interrupt now. There's no point in waiting since we cannot
500 share and the board will usually be enabled. */
Alan Cox055e5112008-07-03 23:43:12 -0700501 ret = request_irq(dev->irq, eip_interrupt, 0, name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (ret) {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500503 pr_cont(" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 goto err_out;
505 }
506
507 dev->base_addr = ioaddr;
508
509#ifdef CONFIG_PLAT_MAPPI
510 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
511 ioaddr + E8390_CMD); /* 0x61 */
Joe Perches104bf3f2011-11-16 09:38:03 +0000512 for (i = 0; i < ETH_ALEN; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 dev->dev_addr[i] = SA_prom[i]
514 = inb_p(ioaddr + EN1_PHYS_SHIFT(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 }
516#else
Joe Perches104bf3f2011-11-16 09:38:03 +0000517 for (i = 0; i < ETH_ALEN; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 dev->dev_addr[i] = SA_prom[i];
519 }
520#endif
521
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500522 pr_cont("%pM\n", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
524 ei_status.name = name;
525 ei_status.tx_start_page = start_page;
526 ei_status.stop_page = stop_page;
Ralf Baechle9cc975e2005-10-10 14:51:21 +0100527
Sergei Shtylyovaedc0e52006-05-09 00:58:28 +0400528 /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */
529 ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
531 ei_status.rx_start_page = start_page + TX_PAGES;
532#ifdef PACKETBUF_MEMSIZE
533 /* Allow the packet buffer size to be overridden by know-it-alls. */
534 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
535#endif
536
537 ei_status.reset_8390 = &ne_reset_8390;
538 ei_status.block_input = &ne_block_input;
539 ei_status.block_output = &ne_block_output;
540 ei_status.get_8390_hdr = &ne_get_8390_hdr;
541 ei_status.priv = 0;
Stephen Hemminger4ef8e762008-11-25 18:26:38 -0800542
543 dev->netdev_ops = &eip_netdev_ops;
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200544 NS8390p_init(dev, 0);
b1fc5502005-05-12 20:11:55 -0400545
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500546 ei_local->msg_enable = ne_msg_enable;
b1fc5502005-05-12 20:11:55 -0400547 ret = register_netdev(dev);
548 if (ret)
549 goto out_irq;
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500550 netdev_info(dev, "%s found at %#lx, using IRQ %d.\n",
551 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561/* Hard reset the card. This used to pause for the same period that a
562 8390 reset command required, but that shouldn't be necessary. */
563
564static void ne_reset_8390(struct net_device *dev)
565{
566 unsigned long reset_start_time = jiffies;
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500567 struct ei_device *ei_local = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500569 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n", jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
572 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
573
574 ei_status.txing = 0;
575 ei_status.dmaing = 0;
576
577 /* This check _should_not_ be necessary, omit eventually. */
578 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800579 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500580 netdev_err(dev, "ne_reset_8390() did not complete.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 break;
582 }
583 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
584}
585
586/* Grab the 8390 specific header. Similar to the block_input routine, but
587 we don't need to be concerned with ring wrap as the header will be at
588 the start of a page, so we optimize accordingly. */
589
590static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
591{
592 int nic_base = dev->base_addr;
593
594 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
595
596 if (ei_status.dmaing)
597 {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500598 netdev_err(dev, "DMAing conflict in ne_get_8390_hdr "
599 "[DMAstat:%d][irqlock:%d].\n",
600 ei_status.dmaing, ei_status.irqlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return;
602 }
603
604 ei_status.dmaing |= 0x01;
605 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
606 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
607 outb_p(0, nic_base + EN0_RCNTHI);
608 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
609 outb_p(ring_page, nic_base + EN0_RSARHI);
610 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
611
612 if (ei_status.word16)
613 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
614 else
615 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
616
617 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
618 ei_status.dmaing &= ~0x01;
619
620 le16_to_cpus(&hdr->count);
621}
622
623/* Block input and output, similar to the Crynwr packet driver. If you
624 are porting to a new ethercard, look at the packet driver source for hints.
625 The NEx000 doesn't share the on-board packet memory -- you have to put
626 the packet out through the "remote DMA" dataport using outb. */
627
628static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
629{
630#ifdef NE_SANITY_CHECK
631 int xfer_count = count;
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500632 struct ei_device *ei_local = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633#endif
634 int nic_base = dev->base_addr;
635 char *buf = skb->data;
636
637 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
638 if (ei_status.dmaing)
639 {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500640 netdev_err(dev, "DMAing conflict in ne_block_input "
641 "[DMAstat:%d][irqlock:%d].\n",
642 ei_status.dmaing, ei_status.irqlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 return;
644 }
645 ei_status.dmaing |= 0x01;
646 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
647 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
648 outb_p(count >> 8, nic_base + EN0_RCNTHI);
649 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
650 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
651 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
652 if (ei_status.word16)
653 {
654 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
655 if (count & 0x01)
656 {
657 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
658#ifdef NE_SANITY_CHECK
659 xfer_count++;
660#endif
661 }
662 } else {
663 insb(NE_BASE + NE_DATAPORT, buf, count);
664 }
665
666#ifdef NE_SANITY_CHECK
667 /* This was for the ALPHA version only, but enough people have
668 been encountering problems so it is still here. If you see
669 this message you either 1) have a slightly incompatible clone
670 or 2) have noise/speed problems with your bus. */
671
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500672 if (netif_msg_rx_status(ei_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 {
674 /* DMA termination address check... */
675 int addr, tries = 20;
676 do {
677 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
678 -- it's broken for Rx on some cards! */
679 int high = inb_p(nic_base + EN0_RSARHI);
680 int low = inb_p(nic_base + EN0_RSARLO);
681 addr = (high << 8) + low;
682 if (((ring_offset + xfer_count) & 0xff) == low)
683 break;
684 } while (--tries > 0);
685 if (tries <= 0)
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500686 netdev_warn(dev, "RX transfer address mismatch,"
687 "%#4.4x (expected) vs. %#4.4x (actual).\n",
688 ring_offset + xfer_count, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 }
690#endif
691 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
692 ei_status.dmaing &= ~0x01;
693}
694
695static void ne_block_output(struct net_device *dev, int count,
696 const unsigned char *buf, const int start_page)
697{
698 int nic_base = NE_BASE;
699 unsigned long dma_start;
700#ifdef NE_SANITY_CHECK
701 int retries = 0;
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500702 struct ei_device *ei_local = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703#endif
704
705 /* Round the count up for word writes. Do we need to do this?
706 What effect will an odd byte count have on the 8390?
707 I should check someday. */
708
709 if (ei_status.word16 && (count & 0x01))
710 count++;
711
712 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
713 if (ei_status.dmaing)
714 {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500715 netdev_err(dev, "DMAing conflict in ne_block_output."
716 "[DMAstat:%d][irqlock:%d]\n",
717 ei_status.dmaing, ei_status.irqlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 return;
719 }
720 ei_status.dmaing |= 0x01;
721 /* We should already be in page 0, but to be safe... */
722 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
723
724#ifdef NE_SANITY_CHECK
725retry:
726#endif
727
728#ifdef NE8390_RW_BUGFIX
729 /* Handle the read-before-write bug the same way as the
730 Crynwr packet driver -- the NatSemi method doesn't work.
731 Actually this doesn't always work either, but if you have
732 problems with your NEx000 this is better than nothing! */
733
734 outb_p(0x42, nic_base + EN0_RCNTLO);
735 outb_p(0x00, nic_base + EN0_RCNTHI);
736 outb_p(0x42, nic_base + EN0_RSARLO);
737 outb_p(0x00, nic_base + EN0_RSARHI);
738 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
739 /* Make certain that the dummy read has occurred. */
740 udelay(6);
741#endif
742
743 outb_p(ENISR_RDC, nic_base + EN0_ISR);
744
745 /* Now the normal output. */
746 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
747 outb_p(count >> 8, nic_base + EN0_RCNTHI);
748 outb_p(0x00, nic_base + EN0_RSARLO);
749 outb_p(start_page, nic_base + EN0_RSARHI);
750
751 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
752 if (ei_status.word16) {
753 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
754 } else {
755 outsb(NE_BASE + NE_DATAPORT, buf, count);
756 }
757
758 dma_start = jiffies;
759
760#ifdef NE_SANITY_CHECK
761 /* This was for the ALPHA version only, but enough people have
762 been encountering problems so it is still here. */
763
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500764 if (netif_msg_tx_queued(ei_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 {
766 /* DMA termination address check... */
767 int addr, tries = 20;
768 do {
769 int high = inb_p(nic_base + EN0_RSARHI);
770 int low = inb_p(nic_base + EN0_RSARLO);
771 addr = (high << 8) + low;
772 if ((start_page << 8) + count == addr)
773 break;
774 } while (--tries > 0);
775
776 if (tries <= 0)
777 {
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500778 netdev_warn(dev, "Tx packet transfer address mismatch,"
779 "%#4.4x (expected) vs. %#4.4x (actual).\n",
780 (start_page << 8) + count, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (retries++ == 0)
782 goto retry;
783 }
784 }
785#endif
786
787 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800788 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500789 netdev_warn(dev, "timeout waiting for Tx RDC.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 ne_reset_8390(dev);
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200791 NS8390p_init(dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 break;
793 }
794
795 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
796 ei_status.dmaing &= ~0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900799static int __init ne_drv_probe(struct platform_device *pdev)
800{
801 struct net_device *dev;
David Friesfbb80232008-09-22 14:10:20 -0700802 int err, this_dev = pdev->id;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900803 struct resource *res;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900804
Alan Cox055e5112008-07-03 23:43:12 -0700805 dev = alloc_eip_netdev();
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900806 if (!dev)
807 return -ENOMEM;
David Friesfbb80232008-09-22 14:10:20 -0700808
809 /* ne.c doesn't populate resources in platform_device, but
810 * rbtx4927_ne_init and rbtx4938_ne_init do register devices
811 * with resources.
812 */
813 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
814 if (res) {
815 dev->base_addr = res->start;
816 dev->irq = platform_get_irq(pdev, 0);
817 } else {
Kulikov Vasiliy33907122010-07-03 05:20:42 +0000818 if (this_dev < 0 || this_dev >= MAX_NE_CARDS) {
819 free_netdev(dev);
David Friesfbb80232008-09-22 14:10:20 -0700820 return -EINVAL;
Kulikov Vasiliy33907122010-07-03 05:20:42 +0000821 }
David Friesfbb80232008-09-22 14:10:20 -0700822 dev->base_addr = io[this_dev];
823 dev->irq = irq[this_dev];
824 dev->mem_end = bad[this_dev];
825 }
Alan Coxda9da012012-11-20 06:31:57 +0000826 SET_NETDEV_DEV(dev, &pdev->dev);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900827 err = do_ne_probe(dev);
828 if (err) {
829 free_netdev(dev);
830 return err;
831 }
832 platform_set_drvdata(pdev, dev);
David Friesfbb80232008-09-22 14:10:20 -0700833
834 /* Update with any values found by probing, don't update if
835 * resources were specified.
836 */
837 if (!res) {
838 io[this_dev] = dev->base_addr;
839 irq[this_dev] = dev->irq;
840 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900841 return 0;
842}
843
David Friesfbb80232008-09-22 14:10:20 -0700844static int ne_drv_remove(struct platform_device *pdev)
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900845{
846 struct net_device *dev = platform_get_drvdata(pdev);
847
David Friesfbb80232008-09-22 14:10:20 -0700848 if (dev) {
849 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
850 netif_device_detach(dev);
851 unregister_netdev(dev);
852 if (idev)
853 pnp_device_detach(idev);
854 /* Careful ne_drv_remove can be called twice, once from
855 * the platform_driver.remove and again when the
856 * platform_device is being removed.
857 */
858 ei_status.priv = 0;
859 free_irq(dev->irq, dev);
860 release_region(dev->base_addr, NE_IO_EXTENT);
861 free_netdev(dev);
David Friesfbb80232008-09-22 14:10:20 -0700862 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900863 return 0;
864}
865
David Friesfbb80232008-09-22 14:10:20 -0700866/* Remove unused devices or all if true. */
867static void ne_loop_rm_unreg(int all)
868{
869 int this_dev;
870 struct platform_device *pdev;
871 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
872 pdev = pdev_ne[this_dev];
873 /* No network device == unused */
874 if (pdev && (!platform_get_drvdata(pdev) || all)) {
875 ne_drv_remove(pdev);
876 platform_device_unregister(pdev);
877 pdev_ne[this_dev] = NULL;
878 }
879 }
880}
881
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900882#ifdef CONFIG_PM
883static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state)
884{
885 struct net_device *dev = platform_get_drvdata(pdev);
886
David Fries539b06f2008-09-08 22:01:14 -0500887 if (netif_running(dev)) {
888 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900889 netif_device_detach(dev);
David Fries539b06f2008-09-08 22:01:14 -0500890 if (idev)
891 pnp_stop_dev(idev);
892 }
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900893 return 0;
894}
895
896static int ne_drv_resume(struct platform_device *pdev)
897{
898 struct net_device *dev = platform_get_drvdata(pdev);
899
900 if (netif_running(dev)) {
David Fries539b06f2008-09-08 22:01:14 -0500901 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
902 if (idev)
903 pnp_start_dev(idev);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900904 ne_reset_8390(dev);
Mikael Petterssond02a4e32008-07-30 13:44:55 +0200905 NS8390p_init(dev, 1);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900906 netif_device_attach(dev);
907 }
908 return 0;
909}
910#else
911#define ne_drv_suspend NULL
912#define ne_drv_resume NULL
913#endif
914
915static struct platform_driver ne_driver = {
David Friesfbb80232008-09-22 14:10:20 -0700916 .remove = ne_drv_remove,
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900917 .suspend = ne_drv_suspend,
918 .resume = ne_drv_resume,
919 .driver = {
920 .name = DRV_NAME,
921 .owner = THIS_MODULE,
922 },
923};
924
David Friesfbb80232008-09-22 14:10:20 -0700925static void __init ne_add_devices(void)
926{
927 int this_dev;
928 struct platform_device *pdev;
929
930 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
931 if (pdev_ne[this_dev])
932 continue;
933 pdev = platform_device_register_simple(
934 DRV_NAME, this_dev, NULL, 0);
935 if (IS_ERR(pdev))
936 continue;
937 pdev_ne[this_dev] = pdev;
938 }
939}
940
941#ifdef MODULE
Hannes Eder2705d4f2008-12-25 23:52:57 -0800942int __init init_module(void)
David Friesfbb80232008-09-22 14:10:20 -0700943{
944 int retval;
945 ne_add_devices();
946 retval = platform_driver_probe(&ne_driver, ne_drv_probe);
947 if (retval) {
948 if (io[0] == 0)
Matthew Whiteheadc45f8122013-12-11 17:00:59 -0500949 pr_notice("ne.c: You must supply \"io=0xNNN\""
950 " value(s) for ISA cards.\n");
David Friesfbb80232008-09-22 14:10:20 -0700951 ne_loop_rm_unreg(1);
952 return retval;
953 }
954
955 /* Unregister unused platform_devices. */
956 ne_loop_rm_unreg(0);
957 return retval;
958}
959#else /* MODULE */
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900960static int __init ne_init(void)
961{
David Friesfbb80232008-09-22 14:10:20 -0700962 int retval = platform_driver_probe(&ne_driver, ne_drv_probe);
963
964 /* Unregister unused platform_devices. */
965 ne_loop_rm_unreg(0);
966 return retval;
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +0900967}
David Friesfbb80232008-09-22 14:10:20 -0700968module_init(ne_init);
969
970struct net_device * __init ne_probe(int unit)
971{
972 int this_dev;
973 struct net_device *dev;
974
975 /* Find an empty slot, that is no net_device and zero io port. */
976 this_dev = 0;
977 while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) ||
978 io[this_dev]) {
979 if (++this_dev == MAX_NE_CARDS)
980 return ERR_PTR(-ENOMEM);
981 }
982
983 /* Get irq, io from kernel command line */
984 dev = alloc_eip_netdev();
985 if (!dev)
986 return ERR_PTR(-ENOMEM);
987
988 sprintf(dev->name, "eth%d", unit);
989 netdev_boot_setup_check(dev);
990
991 io[this_dev] = dev->base_addr;
992 irq[this_dev] = dev->irq;
993 bad[this_dev] = dev->mem_end;
994
995 free_netdev(dev);
996
997 ne_add_devices();
998
999 /* return the first device found */
1000 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
1001 if (pdev_ne[this_dev]) {
1002 dev = platform_get_drvdata(pdev_ne[this_dev]);
1003 if (dev)
1004 return dev;
1005 }
1006 }
1007
1008 return ERR_PTR(-ENODEV);
1009}
1010#endif /* MODULE */
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +09001011
1012static void __exit ne_exit(void)
1013{
1014 platform_driver_unregister(&ne_driver);
David Friesfbb80232008-09-22 14:10:20 -07001015 ne_loop_rm_unreg(1);
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +09001016}
Atsushi Nemotoa4d542b2007-05-01 00:27:31 +09001017module_exit(ne_exit);