1 | // SPDX-License-Identifier: GPL-1.0+ |
2 | /* ne.c: A general non-shared-memory NS8390 ethernet driver for linux. */ |
3 | /* |
4 | Written 1992-94 by Donald Becker. |
5 | |
6 | Copyright 1993 United States Government as represented by the |
7 | Director, National Security Agency. |
8 | |
9 | The author may be reached as becker@scyld.com, or C/O |
10 | Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403 |
11 | |
12 | This driver should work with many programmed-I/O 8390-based ethernet |
13 | boards. Currently it supports the NE1000, NE2000, many clones, |
14 | and some Cabletron products. |
15 | |
16 | Changelog: |
17 | |
18 | Paul Gortmaker : use ENISR_RDC to monitor Tx PIO uploads, made |
19 | sanity checks and bad clone support optional. |
20 | Paul Gortmaker : new reset code, reset card after probe at boot. |
21 | Paul Gortmaker : multiple card support for module users. |
22 | Paul Gortmaker : Support for PCI ne2k clones, similar to lance.c |
23 | Paul Gortmaker : Allow users with bad cards to avoid full probe. |
24 | Paul Gortmaker : PCI probe changes, more PCI cards supported. |
25 | rjohnson@analogic.com : Changed init order so an interrupt will only |
26 | occur after memory is allocated for dev->priv. Deallocated memory |
27 | last in cleanup_modue() |
28 | Richard Guenther : Added support for ISAPnP cards |
29 | Paul Gortmaker : Discontinued PCI support - use ne2k-pci.c instead. |
30 | Hayato Fujiwara : Add m32r support. |
31 | |
32 | */ |
33 | |
34 | /* Routines for the NatSemi-based designs (NE[12]000). */ |
35 | |
36 | static const char version1[] = |
37 | "ne.c:v1.10 9/23/94 Donald Becker (becker@scyld.com)\n" ; |
38 | static const char version2[] = |
39 | "Last modified Nov 1, 2000 by Paul Gortmaker\n" ; |
40 | |
41 | |
42 | #include <linux/module.h> |
43 | #include <linux/kernel.h> |
44 | #include <linux/errno.h> |
45 | #include <linux/isapnp.h> |
46 | #include <linux/init.h> |
47 | #include <linux/interrupt.h> |
48 | #include <linux/delay.h> |
49 | #include <linux/netdevice.h> |
50 | #include <linux/etherdevice.h> |
51 | #include <linux/jiffies.h> |
52 | #include <linux/platform_device.h> |
53 | #include <net/Space.h> |
54 | |
55 | #include <asm/io.h> |
56 | |
57 | #include "8390.h" |
58 | |
59 | #define DRV_NAME "ne" |
60 | |
61 | /* Some defines that people can play with if so inclined. */ |
62 | |
63 | /* Do we support clones that don't adhere to 14,15 of the SAprom ? */ |
64 | #define SUPPORT_NE_BAD_CLONES |
65 | /* 0xbad = bad sig or no reset ack */ |
66 | #define BAD 0xbad |
67 | |
68 | #define MAX_NE_CARDS 4 /* Max number of NE cards per module */ |
69 | static struct platform_device *pdev_ne[MAX_NE_CARDS]; |
70 | static int io[MAX_NE_CARDS]; |
71 | static int irq[MAX_NE_CARDS]; |
72 | static int bad[MAX_NE_CARDS]; |
73 | static u32 ne_msg_enable; |
74 | |
75 | #ifdef MODULE |
76 | module_param_hw_array(io, int, ioport, NULL, 0); |
77 | module_param_hw_array(irq, int, irq, NULL, 0); |
78 | module_param_array(bad, int, NULL, 0); |
79 | module_param_named(msg_enable, ne_msg_enable, uint, 0444); |
80 | MODULE_PARM_DESC(io, "I/O base address(es),required" ); |
81 | MODULE_PARM_DESC(irq, "IRQ number(s)" ); |
82 | MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures" ); |
83 | MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)" ); |
84 | MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver" ); |
85 | MODULE_LICENSE("GPL" ); |
86 | #endif /* MODULE */ |
87 | |
88 | /* Do we perform extra sanity checks on stuff ? */ |
89 | /* #define NE_SANITY_CHECK */ |
90 | |
91 | /* Do we implement the read before write bugfix ? */ |
92 | /* #define NE_RW_BUGFIX */ |
93 | |
94 | /* Do we have a non std. amount of memory? (in units of 256 byte pages) */ |
95 | /* #define PACKETBUF_MEMSIZE 0x40 */ |
96 | |
97 | /* This is set up so that no ISA autoprobe takes place. We can't guarantee |
98 | that the ne2k probe is the last 8390 based probe to take place (as it |
99 | is at boot) and so the probe will get confused by any other 8390 cards. |
100 | ISA device autoprobes on a running machine are not recommended anyway. */ |
101 | #if !defined(MODULE) && defined(CONFIG_ISA) |
102 | /* Do we need a portlist for the ISA auto-probe ? */ |
103 | #define NEEDS_PORTLIST |
104 | #endif |
105 | |
106 | /* A zero-terminated list of I/O addresses to be probed at boot. */ |
107 | #ifdef NEEDS_PORTLIST |
108 | static unsigned int netcard_portlist[] __initdata = { |
109 | 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0 |
110 | }; |
111 | #endif |
112 | |
113 | static struct isapnp_device_id isapnp_clone_list[] __initdata = { |
114 | { ISAPNP_CARD_ID('A','X','E',0x2011), |
115 | ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011), |
116 | (long) "NetGear EA201" }, |
117 | { ISAPNP_ANY_ID, ISAPNP_ANY_ID, |
118 | ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216), |
119 | (long) "NN NE2000" }, |
120 | { ISAPNP_ANY_ID, ISAPNP_ANY_ID, |
121 | ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6), |
122 | (long) "Generic PNP" }, |
123 | { } /* terminate list */ |
124 | }; |
125 | |
126 | MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list); |
127 | |
128 | #ifdef SUPPORT_NE_BAD_CLONES |
129 | /* A list of bad clones that we none-the-less recognize. */ |
130 | static struct { const char *name8, *name16; unsigned char SAprefix[4];} |
131 | bad_clone_list[] __initdata = { |
132 | {"DE100" , "DE200" , {0x00, 0xDE, 0x01,}}, |
133 | {"DE120" , "DE220" , {0x00, 0x80, 0xc8,}}, |
134 | {"DFI1000" , "DFI2000" , {'D', 'F', 'I',}}, /* Original, eh? */ |
135 | {"EtherNext UTP8" , "EtherNext UTP16" , {0x00, 0x00, 0x79}}, |
136 | {"NE1000" ,"NE2000-invalid" , {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */ |
137 | {"NN1000" , "NN2000" , {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */ |
138 | {"4-DIM8" ,"4-DIM16" , {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */ |
139 | {"Con-Intl_8" , "Con-Intl_16" , {0x00, 0x00, 0x24}}, /* Connect Int'nl */ |
140 | {"ET-100" ,"ET-200" , {0x00, 0x45, 0x54}}, /* YANG and YA clone */ |
141 | {"COMPEX" ,"COMPEX16" ,{0x00,0x80,0x48}}, /* Broken ISA Compex cards */ |
142 | {"E-LAN100" , "E-LAN200" , {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */ |
143 | {"PCM-4823" , "PCM-4823" , {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */ |
144 | {"REALTEK" , "RTL8019" , {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */ |
145 | #ifdef CONFIG_MACH_TX49XX |
146 | {"RBHMA4X00-RTL8019" , "RBHMA4X00-RTL8019" , {0x00, 0x60, 0x0a}}, /* Toshiba built-in */ |
147 | #endif |
148 | {"LCS-8834" , "LCS-8836" , {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */ |
149 | {NULL,} |
150 | }; |
151 | #endif |
152 | |
153 | /* ---- No user-serviceable parts below ---- */ |
154 | |
155 | #define NE_BASE (dev->base_addr) |
156 | #define NE_CMD 0x00 |
157 | #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */ |
158 | #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */ |
159 | #define NE_IO_EXTENT 0x20 |
160 | |
161 | #define NE1SM_START_PG 0x20 /* First page of TX buffer */ |
162 | #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */ |
163 | #define NESM_START_PG 0x40 /* First page of TX buffer */ |
164 | #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ |
165 | |
166 | #if defined(CONFIG_MACH_TX49XX) |
167 | # define DCR_VAL 0x48 /* 8-bit mode */ |
168 | #elif defined(CONFIG_ATARI) /* 8-bit mode on Atari, normal on Q40 */ |
169 | # define DCR_VAL (MACH_IS_ATARI ? 0x48 : 0x49) |
170 | #else |
171 | # define DCR_VAL 0x49 |
172 | #endif |
173 | |
174 | static int ne_probe1(struct net_device *dev, unsigned long ioaddr); |
175 | static int ne_probe_isapnp(struct net_device *dev); |
176 | |
177 | static void ne_reset_8390(struct net_device *dev); |
178 | static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, |
179 | int ring_page); |
180 | static void ne_block_input(struct net_device *dev, int count, |
181 | struct sk_buff *skb, int ring_offset); |
182 | static void ne_block_output(struct net_device *dev, const int count, |
183 | const unsigned char *buf, const int start_page); |
184 | |
185 | |
186 | /* Probe for various non-shared-memory ethercards. |
187 | |
188 | NEx000-clone boards have a Station Address PROM (SAPROM) in the packet |
189 | buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of |
190 | the SAPROM, while other supposed NE2000 clones must be detected by their |
191 | SA prefix. |
192 | |
193 | Reading the SAPROM from a word-wide card with the 8390 set in byte-wide |
194 | mode results in doubled values, which can be detected and compensated for. |
195 | |
196 | The probe is also responsible for initializing the card and filling |
197 | in the 'dev' and 'ei_status' structures. |
198 | |
199 | We use the minimum memory size for some ethercard product lines, iff we can't |
200 | distinguish models. You can increase the packet buffer size by setting |
201 | PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are: |
202 | E1010 starts at 0x100 and ends at 0x2000. |
203 | E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory") |
204 | E2010 starts at 0x100 and ends at 0x4000. |
205 | E2010-x starts at 0x100 and ends at 0xffff. */ |
206 | |
207 | static int __init do_ne_probe(struct net_device *dev) |
208 | { |
209 | unsigned long base_addr = dev->base_addr; |
210 | #ifdef NEEDS_PORTLIST |
211 | int orig_irq = dev->irq; |
212 | #endif |
213 | |
214 | /* First check any supplied i/o locations. User knows best. <cough> */ |
215 | if (base_addr > 0x1ff) { /* Check a single specified location. */ |
216 | int ret = ne_probe1(dev, ioaddr: base_addr); |
217 | if (ret) |
218 | netdev_warn(dev, format: "ne.c: No NE*000 card found at " |
219 | "i/o = %#lx\n" , base_addr); |
220 | return ret; |
221 | } |
222 | else if (base_addr != 0) /* Don't probe at all. */ |
223 | return -ENXIO; |
224 | |
225 | /* Then look for any installed ISAPnP clones */ |
226 | if (isapnp_present() && (ne_probe_isapnp(dev) == 0)) |
227 | return 0; |
228 | |
229 | #ifdef NEEDS_PORTLIST |
230 | /* Last resort. The semi-risky ISA auto-probe. */ |
231 | for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) { |
232 | int ioaddr = netcard_portlist[base_addr]; |
233 | dev->irq = orig_irq; |
234 | if (ne_probe1(dev, ioaddr) == 0) |
235 | return 0; |
236 | } |
237 | #endif |
238 | |
239 | return -ENODEV; |
240 | } |
241 | |
242 | static int __init ne_probe_isapnp(struct net_device *dev) |
243 | { |
244 | int i; |
245 | |
246 | for (i = 0; isapnp_clone_list[i].vendor != 0; i++) { |
247 | struct pnp_dev *idev = NULL; |
248 | |
249 | while ((idev = pnp_find_dev(NULL, |
250 | vendor: isapnp_clone_list[i].vendor, |
251 | function: isapnp_clone_list[i].function, |
252 | from: idev))) { |
253 | /* Avoid already found cards from previous calls */ |
254 | if (pnp_device_attach(pnp_dev: idev) < 0) |
255 | continue; |
256 | if (pnp_activate_dev(dev: idev) < 0) { |
257 | pnp_device_detach(pnp_dev: idev); |
258 | continue; |
259 | } |
260 | /* if no io and irq, search for next */ |
261 | if (!pnp_port_valid(dev: idev, bar: 0) || !pnp_irq_valid(dev: idev, bar: 0)) { |
262 | pnp_device_detach(pnp_dev: idev); |
263 | continue; |
264 | } |
265 | /* found it */ |
266 | dev->base_addr = pnp_port_start(dev: idev, bar: 0); |
267 | dev->irq = pnp_irq(dev: idev, bar: 0); |
268 | netdev_info(dev, |
269 | format: "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n" , |
270 | (char *) isapnp_clone_list[i].driver_data, |
271 | dev->base_addr, dev->irq); |
272 | if (ne_probe1(dev, ioaddr: dev->base_addr) != 0) { /* Shouldn't happen. */ |
273 | netdev_err(dev, |
274 | format: "ne.c: Probe of ISAPnP card at %#lx failed.\n" , |
275 | dev->base_addr); |
276 | pnp_device_detach(pnp_dev: 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 | |
290 | static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr) |
291 | { |
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; |
300 | struct ei_device *ei_local = netdev_priv(dev); |
301 | |
302 | if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME)) |
303 | return -EBUSY; |
304 | |
305 | reg0 = inb_p(port: 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, port: ioaddr + E8390_CMD); |
315 | regd = inb_p(port: ioaddr + 0x0d); |
316 | outb_p(value: 0xff, port: ioaddr + 0x0d); |
317 | outb_p(E8390_NODMA+E8390_PAGE0, port: ioaddr + E8390_CMD); |
318 | inb_p(port: ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */ |
319 | if (inb_p(port: ioaddr + EN0_COUNTER0) != 0) { |
320 | outb_p(value: reg0, port: ioaddr); |
321 | outb_p(value: regd, port: ioaddr + 0x0d); /* Restore the old values. */ |
322 | ret = -ENODEV; |
323 | goto err_out; |
324 | } |
325 | } |
326 | |
327 | if ((ne_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0)) |
328 | netdev_info(dev, format: "%s%s" , version1, version2); |
329 | |
330 | netdev_info(dev, format: "NE*000 ethercard probe at %#3lx:" , ioaddr); |
331 | |
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 | |
338 | bad_card = ((dev->base_addr != 0) && (dev->mem_end == BAD)); |
339 | |
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(port: ioaddr + NE_RESET), port: ioaddr + NE_RESET); |
347 | |
348 | while ((inb_p(port: ioaddr + EN0_ISR) & ENISR_RESET) == 0) |
349 | if (time_after(jiffies, reset_start_time + 2*HZ/100)) { |
350 | if (bad_card) { |
351 | pr_cont(" (warning: no reset ack)" ); |
352 | break; |
353 | } else { |
354 | pr_cont(" not found (no reset ack).\n" ); |
355 | ret = -ENODEV; |
356 | goto err_out; |
357 | } |
358 | } |
359 | |
360 | outb_p(value: 0xff, port: ioaddr + EN0_ISR); /* Ack all intr. */ |
361 | } |
362 | |
363 | /* Read the 16 bytes of station address PROM. |
364 | We must first initialize registers, similar to NS8390p_init(eifdev, 0). |
365 | 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 | |
385 | for (i = 0; i < ARRAY_SIZE(program_seq); i++) |
386 | outb_p(value: program_seq[i].value, port: ioaddr + program_seq[i].offset); |
387 | |
388 | } |
389 | for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) { |
390 | SA_prom[i] = inb(port: ioaddr + NE_DATAPORT); |
391 | SA_prom[i+1] = inb(port: 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, port: ioaddr + EN0_DCFG); |
402 | start_page = NESM_START_PG; |
403 | |
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(port: ioaddr + EN0_RCNTLO) == 0x50 && |
412 | inb(port: ioaddr + EN0_RCNTHI) == 0x70) |
413 | stop_page = 0x60; |
414 | else |
415 | stop_page = NESM_STOP_PG; |
416 | } else { |
417 | start_page = NE1SM_START_PG; |
418 | stop_page = NE1SM_STOP_PG; |
419 | } |
420 | |
421 | neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57); |
422 | ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d); |
423 | copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00); |
424 | |
425 | /* Set up the rest of the parameters. */ |
426 | if (neX000 || bad_card || copam) { |
427 | name = (wordlength == 2) ? "NE2000" : "NE1000" ; |
428 | } |
429 | else if (ctron) |
430 | { |
431 | name = (wordlength == 2) ? "Ctron-8" : "Ctron-16" ; |
432 | start_page = 0x01; |
433 | stop_page = (wordlength == 2) ? 0x40 : 0x20; |
434 | } |
435 | else |
436 | { |
437 | #ifdef SUPPORT_NE_BAD_CLONES |
438 | /* Ack! Well, there might be a *bad* NE*000 clone there. |
439 | Check for total bogus addresses. */ |
440 | for (i = 0; bad_clone_list[i].name8; i++) |
441 | { |
442 | if (SA_prom[0] == bad_clone_list[i].SAprefix[0] && |
443 | SA_prom[1] == bad_clone_list[i].SAprefix[1] && |
444 | SA_prom[2] == bad_clone_list[i].SAprefix[2]) |
445 | { |
446 | if (wordlength == 2) |
447 | { |
448 | name = bad_clone_list[i].name16; |
449 | } else { |
450 | name = bad_clone_list[i].name8; |
451 | } |
452 | break; |
453 | } |
454 | } |
455 | if (bad_clone_list[i].name8 == NULL) |
456 | { |
457 | pr_cont(" not found (invalid signature %2.2x %2.2x).\n" , |
458 | SA_prom[14], SA_prom[15]); |
459 | ret = -ENXIO; |
460 | goto err_out; |
461 | } |
462 | #else |
463 | pr_cont(" not found.\n" ); |
464 | ret = -ENXIO; |
465 | goto err_out; |
466 | #endif |
467 | } |
468 | |
469 | if (dev->irq < 2) |
470 | { |
471 | unsigned long cookie = probe_irq_on(); |
472 | outb_p(value: 0x50, port: ioaddr + EN0_IMR); /* Enable one interrupt. */ |
473 | outb_p(value: 0x00, port: ioaddr + EN0_RCNTLO); |
474 | outb_p(value: 0x00, port: ioaddr + EN0_RCNTHI); |
475 | outb_p(E8390_RREAD+E8390_START, port: ioaddr); /* Trigger it... */ |
476 | mdelay(10); /* wait 10ms for interrupt to propagate */ |
477 | outb_p(value: 0x00, port: ioaddr + EN0_IMR); /* Mask it again. */ |
478 | dev->irq = probe_irq_off(cookie); |
479 | if (ne_msg_enable & NETIF_MSG_PROBE) |
480 | pr_cont(" autoirq is %d" , dev->irq); |
481 | } else if (dev->irq == 2) |
482 | /* Fixup for users that don't know that IRQ 2 is really IRQ 9, |
483 | or don't know which one to set. */ |
484 | dev->irq = 9; |
485 | |
486 | if (! dev->irq) { |
487 | pr_cont(" failed to detect IRQ line.\n" ); |
488 | ret = -EAGAIN; |
489 | goto err_out; |
490 | } |
491 | |
492 | /* Snarf the interrupt now. There's no point in waiting since we cannot |
493 | share and the board will usually be enabled. */ |
494 | ret = request_irq(irq: dev->irq, handler: eip_interrupt, flags: 0, name, dev); |
495 | if (ret) { |
496 | pr_cont(" unable to get IRQ %d (errno=%d).\n" , dev->irq, ret); |
497 | goto err_out; |
498 | } |
499 | |
500 | dev->base_addr = ioaddr; |
501 | |
502 | eth_hw_addr_set(dev, addr: SA_prom); |
503 | |
504 | pr_cont("%pM\n" , dev->dev_addr); |
505 | |
506 | ei_status.name = name; |
507 | ei_status.tx_start_page = start_page; |
508 | ei_status.stop_page = stop_page; |
509 | |
510 | /* Use 16-bit mode only if this wasn't overridden by DCR_VAL */ |
511 | ei_status.word16 = (wordlength == 2 && (DCR_VAL & 0x01)); |
512 | |
513 | ei_status.rx_start_page = start_page + TX_PAGES; |
514 | #ifdef PACKETBUF_MEMSIZE |
515 | /* Allow the packet buffer size to be overridden by know-it-alls. */ |
516 | ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE; |
517 | #endif |
518 | |
519 | ei_status.reset_8390 = &ne_reset_8390; |
520 | ei_status.block_input = &ne_block_input; |
521 | ei_status.block_output = &ne_block_output; |
522 | ei_status.get_8390_hdr = &ne_get_8390_hdr; |
523 | ei_status.priv = 0; |
524 | |
525 | dev->netdev_ops = &eip_netdev_ops; |
526 | NS8390p_init(dev, startp: 0); |
527 | |
528 | ei_local->msg_enable = ne_msg_enable; |
529 | ret = register_netdev(dev); |
530 | if (ret) |
531 | goto out_irq; |
532 | netdev_info(dev, format: "%s found at %#lx, using IRQ %d.\n" , |
533 | name, ioaddr, dev->irq); |
534 | return 0; |
535 | |
536 | out_irq: |
537 | free_irq(dev->irq, dev); |
538 | err_out: |
539 | release_region(ioaddr, NE_IO_EXTENT); |
540 | return ret; |
541 | } |
542 | |
543 | /* Hard reset the card. This used to pause for the same period that a |
544 | 8390 reset command required, but that shouldn't be necessary. */ |
545 | |
546 | static void ne_reset_8390(struct net_device *dev) |
547 | { |
548 | unsigned long reset_start_time = jiffies; |
549 | struct ei_device *ei_local = netdev_priv(dev); |
550 | |
551 | netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n" , jiffies); |
552 | |
553 | /* DON'T change these to inb_p/outb_p or reset will fail on clones. */ |
554 | outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); |
555 | |
556 | ei_status.txing = 0; |
557 | ei_status.dmaing = 0; |
558 | |
559 | /* This check _should_not_ be necessary, omit eventually. */ |
560 | while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0) |
561 | if (time_after(jiffies, reset_start_time + 2*HZ/100)) { |
562 | netdev_err(dev, format: "ne_reset_8390() did not complete.\n" ); |
563 | break; |
564 | } |
565 | outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */ |
566 | } |
567 | |
568 | /* Grab the 8390 specific header. Similar to the block_input routine, but |
569 | we don't need to be concerned with ring wrap as the header will be at |
570 | the start of a page, so we optimize accordingly. */ |
571 | |
572 | static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) |
573 | { |
574 | int nic_base = dev->base_addr; |
575 | |
576 | /* This *shouldn't* happen. If it does, it's the last thing you'll see */ |
577 | |
578 | if (ei_status.dmaing) |
579 | { |
580 | netdev_err(dev, format: "DMAing conflict in ne_get_8390_hdr " |
581 | "[DMAstat:%d][irqlock:%d].\n" , |
582 | ei_status.dmaing, ei_status.irqlock); |
583 | return; |
584 | } |
585 | |
586 | ei_status.dmaing |= 0x01; |
587 | outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, port: nic_base+ NE_CMD); |
588 | outb_p(value: sizeof(struct e8390_pkt_hdr), port: nic_base + EN0_RCNTLO); |
589 | outb_p(value: 0, port: nic_base + EN0_RCNTHI); |
590 | outb_p(value: 0, port: nic_base + EN0_RSARLO); /* On page boundary */ |
591 | outb_p(value: ring_page, port: nic_base + EN0_RSARHI); |
592 | outb_p(E8390_RREAD+E8390_START, port: nic_base + NE_CMD); |
593 | |
594 | if (ei_status.word16) |
595 | insw(NE_BASE + NE_DATAPORT, addr: hdr, count: sizeof(struct e8390_pkt_hdr)>>1); |
596 | else |
597 | insb(NE_BASE + NE_DATAPORT, addr: hdr, count: sizeof(struct e8390_pkt_hdr)); |
598 | |
599 | outb_p(ENISR_RDC, port: nic_base + EN0_ISR); /* Ack intr. */ |
600 | ei_status.dmaing &= ~0x01; |
601 | |
602 | le16_to_cpus(&hdr->count); |
603 | } |
604 | |
605 | /* Block input and output, similar to the Crynwr packet driver. If you |
606 | are porting to a new ethercard, look at the packet driver source for hints. |
607 | The NEx000 doesn't share the on-board packet memory -- you have to put |
608 | the packet out through the "remote DMA" dataport using outb. */ |
609 | |
610 | static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) |
611 | { |
612 | #ifdef NE_SANITY_CHECK |
613 | int xfer_count = count; |
614 | struct ei_device *ei_local = netdev_priv(dev); |
615 | #endif |
616 | int nic_base = dev->base_addr; |
617 | char *buf = skb->data; |
618 | |
619 | /* This *shouldn't* happen. If it does, it's the last thing you'll see */ |
620 | if (ei_status.dmaing) |
621 | { |
622 | netdev_err(dev, format: "DMAing conflict in ne_block_input " |
623 | "[DMAstat:%d][irqlock:%d].\n" , |
624 | ei_status.dmaing, ei_status.irqlock); |
625 | return; |
626 | } |
627 | ei_status.dmaing |= 0x01; |
628 | outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, port: nic_base+ NE_CMD); |
629 | outb_p(value: count & 0xff, port: nic_base + EN0_RCNTLO); |
630 | outb_p(value: count >> 8, port: nic_base + EN0_RCNTHI); |
631 | outb_p(value: ring_offset & 0xff, port: nic_base + EN0_RSARLO); |
632 | outb_p(value: ring_offset >> 8, port: nic_base + EN0_RSARHI); |
633 | outb_p(E8390_RREAD+E8390_START, port: nic_base + NE_CMD); |
634 | if (ei_status.word16) |
635 | { |
636 | insw(NE_BASE + NE_DATAPORT,addr: buf,count: count>>1); |
637 | if (count & 0x01) |
638 | { |
639 | buf[count-1] = inb(NE_BASE + NE_DATAPORT); |
640 | #ifdef NE_SANITY_CHECK |
641 | xfer_count++; |
642 | #endif |
643 | } |
644 | } else { |
645 | insb(NE_BASE + NE_DATAPORT, addr: buf, count); |
646 | } |
647 | |
648 | #ifdef NE_SANITY_CHECK |
649 | /* This was for the ALPHA version only, but enough people have |
650 | been encountering problems so it is still here. If you see |
651 | this message you either 1) have a slightly incompatible clone |
652 | or 2) have noise/speed problems with your bus. */ |
653 | |
654 | if (netif_msg_rx_status(ei_local)) |
655 | { |
656 | /* DMA termination address check... */ |
657 | int addr, tries = 20; |
658 | do { |
659 | /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here |
660 | -- it's broken for Rx on some cards! */ |
661 | int high = inb_p(nic_base + EN0_RSARHI); |
662 | int low = inb_p(nic_base + EN0_RSARLO); |
663 | addr = (high << 8) + low; |
664 | if (((ring_offset + xfer_count) & 0xff) == low) |
665 | break; |
666 | } while (--tries > 0); |
667 | if (tries <= 0) |
668 | netdev_warn(dev, "RX transfer address mismatch," |
669 | "%#4.4x (expected) vs. %#4.4x (actual).\n" , |
670 | ring_offset + xfer_count, addr); |
671 | } |
672 | #endif |
673 | outb_p(ENISR_RDC, port: nic_base + EN0_ISR); /* Ack intr. */ |
674 | ei_status.dmaing &= ~0x01; |
675 | } |
676 | |
677 | static void ne_block_output(struct net_device *dev, int count, |
678 | const unsigned char *buf, const int start_page) |
679 | { |
680 | int nic_base = NE_BASE; |
681 | unsigned long dma_start; |
682 | #ifdef NE_SANITY_CHECK |
683 | int retries = 0; |
684 | struct ei_device *ei_local = netdev_priv(dev); |
685 | #endif |
686 | |
687 | /* Round the count up for word writes. Do we need to do this? |
688 | What effect will an odd byte count have on the 8390? |
689 | I should check someday. */ |
690 | |
691 | if (ei_status.word16 && (count & 0x01)) |
692 | count++; |
693 | |
694 | /* This *shouldn't* happen. If it does, it's the last thing you'll see */ |
695 | if (ei_status.dmaing) |
696 | { |
697 | netdev_err(dev, format: "DMAing conflict in ne_block_output." |
698 | "[DMAstat:%d][irqlock:%d]\n" , |
699 | ei_status.dmaing, ei_status.irqlock); |
700 | return; |
701 | } |
702 | ei_status.dmaing |= 0x01; |
703 | /* We should already be in page 0, but to be safe... */ |
704 | outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, port: nic_base + NE_CMD); |
705 | |
706 | #ifdef NE_SANITY_CHECK |
707 | retry: |
708 | #endif |
709 | |
710 | #ifdef NE_RW_BUGFIX |
711 | /* Handle the read-before-write bug the same way as the |
712 | Crynwr packet driver -- the NatSemi method doesn't work. |
713 | Actually this doesn't always work either, but if you have |
714 | problems with your NEx000 this is better than nothing! */ |
715 | |
716 | outb_p(0x42, nic_base + EN0_RCNTLO); |
717 | outb_p(0x00, nic_base + EN0_RCNTHI); |
718 | outb_p(0x42, nic_base + EN0_RSARLO); |
719 | outb_p(0x00, nic_base + EN0_RSARHI); |
720 | outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD); |
721 | /* Make certain that the dummy read has occurred. */ |
722 | udelay(6); |
723 | #endif |
724 | |
725 | outb_p(ENISR_RDC, port: nic_base + EN0_ISR); |
726 | |
727 | /* Now the normal output. */ |
728 | outb_p(value: count & 0xff, port: nic_base + EN0_RCNTLO); |
729 | outb_p(value: count >> 8, port: nic_base + EN0_RCNTHI); |
730 | outb_p(value: 0x00, port: nic_base + EN0_RSARLO); |
731 | outb_p(value: start_page, port: nic_base + EN0_RSARHI); |
732 | |
733 | outb_p(E8390_RWRITE+E8390_START, port: nic_base + NE_CMD); |
734 | if (ei_status.word16) { |
735 | outsw(NE_BASE + NE_DATAPORT, addr: buf, count: count>>1); |
736 | } else { |
737 | outsb(NE_BASE + NE_DATAPORT, addr: buf, count); |
738 | } |
739 | |
740 | dma_start = jiffies; |
741 | |
742 | #ifdef NE_SANITY_CHECK |
743 | /* This was for the ALPHA version only, but enough people have |
744 | been encountering problems so it is still here. */ |
745 | |
746 | if (netif_msg_tx_queued(ei_local)) |
747 | { |
748 | /* DMA termination address check... */ |
749 | int addr, tries = 20; |
750 | do { |
751 | int high = inb_p(nic_base + EN0_RSARHI); |
752 | int low = inb_p(nic_base + EN0_RSARLO); |
753 | addr = (high << 8) + low; |
754 | if ((start_page << 8) + count == addr) |
755 | break; |
756 | } while (--tries > 0); |
757 | |
758 | if (tries <= 0) |
759 | { |
760 | netdev_warn(dev, "Tx packet transfer address mismatch," |
761 | "%#4.4x (expected) vs. %#4.4x (actual).\n" , |
762 | (start_page << 8) + count, addr); |
763 | if (retries++ == 0) |
764 | goto retry; |
765 | } |
766 | } |
767 | #endif |
768 | |
769 | while ((inb_p(port: nic_base + EN0_ISR) & ENISR_RDC) == 0) |
770 | if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */ |
771 | netdev_warn(dev, format: "timeout waiting for Tx RDC.\n" ); |
772 | ne_reset_8390(dev); |
773 | NS8390p_init(dev, startp: 1); |
774 | break; |
775 | } |
776 | |
777 | outb_p(ENISR_RDC, port: nic_base + EN0_ISR); /* Ack intr. */ |
778 | ei_status.dmaing &= ~0x01; |
779 | } |
780 | |
781 | static int __init ne_drv_probe(struct platform_device *pdev) |
782 | { |
783 | struct net_device *dev; |
784 | int err, this_dev = pdev->id; |
785 | struct resource *res; |
786 | |
787 | dev = alloc_eip_netdev(); |
788 | if (!dev) |
789 | return -ENOMEM; |
790 | |
791 | /* ne.c doesn't populate resources in platform_device, but |
792 | * rbtx4927_ne_init and rbtx4938_ne_init do register devices |
793 | * with resources. |
794 | */ |
795 | res = platform_get_resource(pdev, IORESOURCE_IO, 0); |
796 | if (res) { |
797 | dev->base_addr = res->start; |
798 | dev->irq = platform_get_irq(pdev, 0); |
799 | } else { |
800 | if (this_dev < 0 || this_dev >= MAX_NE_CARDS) { |
801 | free_netdev(dev); |
802 | return -EINVAL; |
803 | } |
804 | dev->base_addr = io[this_dev]; |
805 | dev->irq = irq[this_dev]; |
806 | dev->mem_end = bad[this_dev]; |
807 | } |
808 | SET_NETDEV_DEV(dev, &pdev->dev); |
809 | err = do_ne_probe(dev); |
810 | if (err) { |
811 | free_netdev(dev); |
812 | return err; |
813 | } |
814 | platform_set_drvdata(pdev, data: dev); |
815 | |
816 | /* Update with any values found by probing, don't update if |
817 | * resources were specified. |
818 | */ |
819 | if (!res) { |
820 | io[this_dev] = dev->base_addr; |
821 | irq[this_dev] = dev->irq; |
822 | } |
823 | return 0; |
824 | } |
825 | |
826 | static void ne_drv_remove(struct platform_device *pdev) |
827 | { |
828 | struct net_device *dev = platform_get_drvdata(pdev); |
829 | |
830 | if (dev) { |
831 | struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; |
832 | netif_device_detach(dev); |
833 | unregister_netdev(dev); |
834 | if (idev) |
835 | pnp_device_detach(pnp_dev: idev); |
836 | /* Careful ne_drv_remove can be called twice, once from |
837 | * the platform_driver.remove and again when the |
838 | * platform_device is being removed. |
839 | */ |
840 | ei_status.priv = 0; |
841 | free_irq(dev->irq, dev); |
842 | release_region(dev->base_addr, NE_IO_EXTENT); |
843 | free_netdev(dev); |
844 | } |
845 | } |
846 | |
847 | /* Remove unused devices or all if true. */ |
848 | static void ne_loop_rm_unreg(int all) |
849 | { |
850 | int this_dev; |
851 | struct platform_device *pdev; |
852 | for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { |
853 | pdev = pdev_ne[this_dev]; |
854 | /* No network device == unused */ |
855 | if (pdev && (!platform_get_drvdata(pdev) || all)) { |
856 | ne_drv_remove(pdev); |
857 | platform_device_unregister(pdev); |
858 | pdev_ne[this_dev] = NULL; |
859 | } |
860 | } |
861 | } |
862 | |
863 | #ifdef CONFIG_PM |
864 | static int ne_drv_suspend(struct platform_device *pdev, pm_message_t state) |
865 | { |
866 | struct net_device *dev = platform_get_drvdata(pdev); |
867 | |
868 | if (netif_running(dev)) { |
869 | struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; |
870 | netif_device_detach(dev); |
871 | if (idev) |
872 | pnp_stop_dev(dev: idev); |
873 | } |
874 | return 0; |
875 | } |
876 | |
877 | static int ne_drv_resume(struct platform_device *pdev) |
878 | { |
879 | struct net_device *dev = platform_get_drvdata(pdev); |
880 | |
881 | if (netif_running(dev)) { |
882 | struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv; |
883 | if (idev) |
884 | pnp_start_dev(dev: idev); |
885 | ne_reset_8390(dev); |
886 | NS8390p_init(dev, startp: 1); |
887 | netif_device_attach(dev); |
888 | } |
889 | return 0; |
890 | } |
891 | #else |
892 | #define ne_drv_suspend NULL |
893 | #define ne_drv_resume NULL |
894 | #endif |
895 | |
896 | static struct platform_driver ne_driver = { |
897 | .remove_new = ne_drv_remove, |
898 | .suspend = ne_drv_suspend, |
899 | .resume = ne_drv_resume, |
900 | .driver = { |
901 | .name = DRV_NAME, |
902 | }, |
903 | }; |
904 | |
905 | static void __init ne_add_devices(void) |
906 | { |
907 | int this_dev; |
908 | struct platform_device *pdev; |
909 | |
910 | for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { |
911 | if (pdev_ne[this_dev]) |
912 | continue; |
913 | pdev = platform_device_register_simple( |
914 | DRV_NAME, id: this_dev, NULL, num: 0); |
915 | if (IS_ERR(ptr: pdev)) |
916 | continue; |
917 | pdev_ne[this_dev] = pdev; |
918 | } |
919 | } |
920 | |
921 | static int __init ne_init(void) |
922 | { |
923 | int retval; |
924 | |
925 | if (IS_MODULE(CONFIG_NE2000)) |
926 | ne_add_devices(); |
927 | |
928 | retval = platform_driver_probe(&ne_driver, ne_drv_probe); |
929 | |
930 | if (IS_MODULE(CONFIG_NE2000) && retval) { |
931 | if (io[0] == 0) |
932 | pr_notice("ne.c: You must supply \"io=0xNNN\"" |
933 | " value(s) for ISA cards.\n" ); |
934 | ne_loop_rm_unreg(all: 1); |
935 | return retval; |
936 | } |
937 | |
938 | /* Unregister unused platform_devices. */ |
939 | ne_loop_rm_unreg(all: 0); |
940 | return retval; |
941 | } |
942 | module_init(ne_init); |
943 | |
944 | #if !defined(MODULE) && defined(CONFIG_NETDEV_LEGACY_INIT) |
945 | struct net_device * __init ne_probe(int unit) |
946 | { |
947 | int this_dev; |
948 | struct net_device *dev; |
949 | |
950 | /* Find an empty slot, that is no net_device and zero io port. */ |
951 | this_dev = 0; |
952 | while ((pdev_ne[this_dev] && platform_get_drvdata(pdev_ne[this_dev])) || |
953 | io[this_dev]) { |
954 | if (++this_dev == MAX_NE_CARDS) |
955 | return ERR_PTR(-ENOMEM); |
956 | } |
957 | |
958 | /* Get irq, io from kernel command line */ |
959 | dev = alloc_eip_netdev(); |
960 | if (!dev) |
961 | return ERR_PTR(-ENOMEM); |
962 | |
963 | sprintf(dev->name, "eth%d" , unit); |
964 | netdev_boot_setup_check(dev); |
965 | |
966 | io[this_dev] = dev->base_addr; |
967 | irq[this_dev] = dev->irq; |
968 | bad[this_dev] = dev->mem_end; |
969 | |
970 | free_netdev(dev); |
971 | |
972 | ne_add_devices(); |
973 | |
974 | /* return the first device found */ |
975 | for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) { |
976 | if (pdev_ne[this_dev]) { |
977 | dev = platform_get_drvdata(pdev_ne[this_dev]); |
978 | if (dev) |
979 | return dev; |
980 | } |
981 | } |
982 | |
983 | return ERR_PTR(-ENODEV); |
984 | } |
985 | #endif |
986 | |
987 | static void __exit ne_exit(void) |
988 | { |
989 | platform_driver_unregister(&ne_driver); |
990 | ne_loop_rm_unreg(all: 1); |
991 | } |
992 | module_exit(ne_exit); |
993 | |