]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/net/ne.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
au1000_eth.c: use ether_crc() from <linux/crc32.h>
[mirror_ubuntu-bionic-kernel.git] / drivers / net / ne.c
CommitLineData
1da177e4
LT		 1/* 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>
ff5688ae 53#include <linux/jiffies.h>
1da177e4
LT		 54
55#include <asm/system.h>
56#include <asm/io.h>
57
9cc975e0
RB		 58#if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
59#include <asm/tx4938/rbtx4938.h>
60#endif
61
1da177e4
LT		 62#include "8390.h"
63
64#define DRV_NAME "ne"
65
66/* Some defines that people can play with if so inclined. */
67
68/* Do we support clones that don't adhere to 14,15 of the SAprom ? */
69#define SUPPORT_NE_BAD_CLONES
70
71/* Do we perform extra sanity checks on stuff ? */
72/* #define NE_SANITY_CHECK */
73
74/* Do we implement the read before write bugfix ? */
75/* #define NE_RW_BUGFIX */
76
77/* Do we have a non std. amount of memory? (in units of 256 byte pages) */
78/* #define PACKETBUF_MEMSIZE 0x40 */
79
80/* A zero-terminated list of I/O addresses to be probed at boot. */
81#ifndef MODULE
82static unsigned int netcard_portlist[] __initdata = {
83 0x300, 0x280, 0x320, 0x340, 0x360, 0x380, 0
84};
85#endif
86
87static struct isapnp_device_id isapnp_clone_list[] __initdata = {
88 { ISAPNP_CARD_ID('A','X','E',0x2011),
89 ISAPNP_VENDOR('A','X','E'), ISAPNP_FUNCTION(0x2011),
90 (long) "NetGear EA201" },
91 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
92 ISAPNP_VENDOR('E','D','I'), ISAPNP_FUNCTION(0x0216),
93 (long) "NN NE2000" },
94 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
95 ISAPNP_VENDOR('P','N','P'), ISAPNP_FUNCTION(0x80d6),
96 (long) "Generic PNP" },
97 { } /* terminate list */
98};
99
100MODULE_DEVICE_TABLE(isapnp, isapnp_clone_list);
101
102#ifdef SUPPORT_NE_BAD_CLONES
103/* A list of bad clones that we none-the-less recognize. */
104static struct { const char *name8, *name16; unsigned char SAprefix[4];}
105bad_clone_list[] __initdata = {
106 {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
107 {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
108 {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */
109 {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
110 {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
111 {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
112 {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */
113 {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
114 {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */
115 {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */
116 {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
117 {"PCM-4823", "PCM-4823", {0x00, 0xc0, 0x6c}}, /* Broken Advantech MoBo */
118 {"REALTEK", "RTL8019", {0x00, 0x00, 0xe8}}, /* no-name with Realtek chip */
9cc975e0
RB		 119#if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
120 {"RBHMA4X00-RTL8019", "RBHMA4X00/RTL8019", {0x00, 0x60, 0x0a}}, /* Toshiba built-in */
121#endif
1da177e4
LT		 122 {"LCS-8834", "LCS-8836", {0x04, 0x04, 0x37}}, /* ShinyNet (SET) */
123 {NULL,}
124};
125#endif
126
127/* ---- No user-serviceable parts below ---- */
128
129#define NE_BASE (dev->base_addr)
130#define NE_CMD 0x00
131#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
132#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
133#define NE_IO_EXTENT 0x20
134
135#define NE1SM_START_PG 0x20 /* First page of TX buffer */
136#define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
137#define NESM_START_PG 0x40 /* First page of TX buffer */
138#define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
139
44456d37 140#if defined(CONFIG_PLAT_MAPPI)
1da177e4 141# define DCR_VAL 0x4b
44456d37 142#elif defined(CONFIG_PLAT_OAKS32R)
1da177e4
LT		 143# define DCR_VAL 0x48
144#else
145# define DCR_VAL 0x49
146#endif
147
148static int ne_probe1(struct net_device *dev, int ioaddr);
149static int ne_probe_isapnp(struct net_device *dev);
150
151static int ne_open(struct net_device *dev);
152static int ne_close(struct net_device *dev);
153
154static void ne_reset_8390(struct net_device *dev);
155static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
156 int ring_page);
157static void ne_block_input(struct net_device *dev, int count,
158 struct sk_buff *skb, int ring_offset);
159static void ne_block_output(struct net_device *dev, const int count,
160 const unsigned char *buf, const int start_page);
161
162\f
163/* Probe for various non-shared-memory ethercards.
164
165 NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
166 buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
167 the SAPROM, while other supposed NE2000 clones must be detected by their
168 SA prefix.
169
170 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
171 mode results in doubled values, which can be detected and compensated for.
172
173 The probe is also responsible for initializing the card and filling
174 in the 'dev' and 'ei_status' structures.
175
176 We use the minimum memory size for some ethercard product lines, iff we can't
177 distinguish models. You can increase the packet buffer size by setting
178 PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are:
179 E1010 starts at 0x100 and ends at 0x2000.
180 E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
181 E2010 starts at 0x100 and ends at 0x4000.
182 E2010-x starts at 0x100 and ends at 0xffff. */
183
184static int __init do_ne_probe(struct net_device *dev)
185{
186 unsigned int base_addr = dev->base_addr;
187#ifndef MODULE
188 int orig_irq = dev->irq;
189#endif
190
191 SET_MODULE_OWNER(dev);
192
193 /* First check any supplied i/o locations. User knows best. <cough> */
194 if (base_addr > 0x1ff) /* Check a single specified location. */
195 return ne_probe1(dev, base_addr);
196 else if (base_addr != 0) /* Don't probe at all. */
197 return -ENXIO;
198
199 /* Then look for any installed ISAPnP clones */
200 if (isapnp_present() && (ne_probe_isapnp(dev) == 0))
201 return 0;
202
203#ifndef MODULE
204 /* Last resort. The semi-risky ISA auto-probe. */
205 for (base_addr = 0; netcard_portlist[base_addr] != 0; base_addr++) {
206 int ioaddr = netcard_portlist[base_addr];
207 dev->irq = orig_irq;
208 if (ne_probe1(dev, ioaddr) == 0)
209 return 0;
210 }
211#endif
212
213 return -ENODEV;
214}
215
1da177e4
LT		 216#ifndef MODULE
217struct net_device * __init ne_probe(int unit)
218{
219 struct net_device *dev = alloc_ei_netdev();
220 int err;
221
222 if (!dev)
223 return ERR_PTR(-ENOMEM);
224
225 sprintf(dev->name, "eth%d", unit);
226 netdev_boot_setup_check(dev);
227
9cc975e0 228#ifdef CONFIG_TOSHIBA_RBTX4938
17c281ab 229 dev->base_addr = RBTX4938_RTL_8019_BASE;
9cc975e0
RB		 230 dev->irq = RBTX4938_RTL_8019_IRQ;
231#endif
1da177e4
LT		 232 err = do_ne_probe(dev);
233 if (err)
234 goto out;
1da177e4 235 return dev;
1da177e4
LT		 236out:
237 free_netdev(dev);
238 return ERR_PTR(err);
239}
240#endif
241
242static 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 isapnp_clone_list[i].vendor,
251 isapnp_clone_list[i].function,
252 idev))) {
253 /* Avoid already found cards from previous calls */
254 if (pnp_device_attach(idev) < 0)
255 continue;
256 if (pnp_activate_dev(idev) < 0) {
257 pnp_device_detach(idev);
258 continue;
259 }
260 /* if no io and irq, search for next */
261 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
262 pnp_device_detach(idev);
263 continue;
264 }
265 /* found it */
266 dev->base_addr = pnp_port_start(idev, 0);
267 dev->irq = pnp_irq(idev, 0);
268 printk(KERN_INFO "ne.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
269 (char *) isapnp_clone_list[i].driver_data,
270 dev->base_addr, dev->irq);
271 if (ne_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
272 printk(KERN_ERR "ne.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
273 pnp_device_detach(idev);
274 return -ENXIO;
275 }
276 ei_status.priv = (unsigned long)idev;
277 break;
278 }
279 if (!idev)
280 continue;
281 return 0;
282 }
283
284 return -ENODEV;
285}
286
287static int __init ne_probe1(struct net_device *dev, int ioaddr)
288{
289 int i;
290 unsigned char SA_prom[32];
291 int wordlength = 2;
292 const char *name = NULL;
293 int start_page, stop_page;
294 int neX000, ctron, copam, bad_card;
295 int reg0, ret;
296 static unsigned version_printed;
297
298 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME))
299 return -EBUSY;
300
301 reg0 = inb_p(ioaddr);
302 if (reg0 == 0xFF) {
303 ret = -ENODEV;
304 goto err_out;
305 }
306
307 /* Do a preliminary verification that we have a 8390. */
308 {
309 int regd;
310 outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
311 regd = inb_p(ioaddr + 0x0d);
312 outb_p(0xff, ioaddr + 0x0d);
313 outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
314 inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
315 if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
316 outb_p(reg0, ioaddr);
317 outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */
318 ret = -ENODEV;
319 goto err_out;
320 }
321 }
322
323 if (ei_debug && version_printed++ == 0)
324 printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2);
325
326 printk(KERN_INFO "NE*000 ethercard probe at %#3x:", ioaddr);
327
328 /* A user with a poor card that fails to ack the reset, or that
329 does not have a valid 0x57,0x57 signature can still use this
330 without having to recompile. Specifying an i/o address along
331 with an otherwise unused dev->mem_end value of "0xBAD" will
332 cause the driver to skip these parts of the probe. */
333
334 bad_card = ((dev->base_addr != 0) && (dev->mem_end == 0xbad));
335
336 /* Reset card. Who knows what dain-bramaged state it was left in. */
337
338 {
339 unsigned long reset_start_time = jiffies;
340
341 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
342 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
343
344 while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
ff5688ae 345 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4
LT		 346 if (bad_card) {
347 printk(" (warning: no reset ack)");
348 break;
349 } else {
350 printk(" not found (no reset ack).\n");
351 ret = -ENODEV;
352 goto err_out;
353 }
354 }
355
356 outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
357 }
358
359 /* Read the 16 bytes of station address PROM.
360 We must first initialize registers, similar to NS8390_init(eifdev, 0).
361 We can't reliably read the SAPROM address without this.
362 (I learned the hard way!). */
363 {
364 struct {unsigned char value, offset; } program_seq[] =
365 {
366 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
367 {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
368 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
369 {0x00, EN0_RCNTHI},
370 {0x00, EN0_IMR}, /* Mask completion irq. */
371 {0xFF, EN0_ISR},
372 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
373 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
374 {32, EN0_RCNTLO},
375 {0x00, EN0_RCNTHI},
376 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
377 {0x00, EN0_RSARHI},
378 {E8390_RREAD+E8390_START, E8390_CMD},
379 };
380
381 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
382 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
383
384 }
385 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
386 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
387 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
388 if (SA_prom[i] != SA_prom[i+1])
389 wordlength = 1;
390 }
391
392 if (wordlength == 2)
393 {
394 for (i = 0; i < 16; i++)
395 SA_prom[i] = SA_prom[i+i];
396 /* We must set the 8390 for word mode. */
397 outb_p(DCR_VAL, ioaddr + EN0_DCFG);
398 start_page = NESM_START_PG;
399 stop_page = NESM_STOP_PG;
400 } else {
401 start_page = NE1SM_START_PG;
402 stop_page = NE1SM_STOP_PG;
403 }
404
405#if defined(CONFIG_PLAT_MAPPI) || defined(CONFIG_PLAT_OAKS32R)
406 neX000 = ((SA_prom[14] == 0x57 && SA_prom[15] == 0x57)
407 || (SA_prom[14] == 0x42 && SA_prom[15] == 0x42));
408#else
409 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
410#endif
411 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
412 copam = (SA_prom[14] == 0x49 && SA_prom[15] == 0x00);
413
414 /* Set up the rest of the parameters. */
415 if (neX000 || bad_card || copam) {
416 name = (wordlength == 2) ? "NE2000" : "NE1000";
417 }
418 else if (ctron)
419 {
420 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
421 start_page = 0x01;
422 stop_page = (wordlength == 2) ? 0x40 : 0x20;
423 }
424 else
425 {
426#ifdef SUPPORT_NE_BAD_CLONES
427 /* Ack! Well, there might be a *bad* NE*000 clone there.
428 Check for total bogus addresses. */
429 for (i = 0; bad_clone_list[i].name8; i++)
430 {
431 if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
432 SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
433 SA_prom[2] == bad_clone_list[i].SAprefix[2])
434 {
435 if (wordlength == 2)
436 {
437 name = bad_clone_list[i].name16;
438 } else {
439 name = bad_clone_list[i].name8;
440 }
441 break;
442 }
443 }
444 if (bad_clone_list[i].name8 == NULL)
445 {
446 printk(" not found (invalid signature %2.2x %2.2x).\n",
447 SA_prom[14], SA_prom[15]);
448 ret = -ENXIO;
449 goto err_out;
450 }
451#else
452 printk(" not found.\n");
453 ret = -ENXIO;
454 goto err_out;
455#endif
456 }
457
458 if (dev->irq < 2)
459 {
460 unsigned long cookie = probe_irq_on();
461 outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */
462 outb_p(0x00, ioaddr + EN0_RCNTLO);
463 outb_p(0x00, ioaddr + EN0_RCNTHI);
464 outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
465 mdelay(10); /* wait 10ms for interrupt to propagate */
466 outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */
467 dev->irq = probe_irq_off(cookie);
468 if (ei_debug > 2)
469 printk(" autoirq is %d\n", dev->irq);
470 } else if (dev->irq == 2)
471 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
472 or don't know which one to set. */
473 dev->irq = 9;
474
475 if (! dev->irq) {
476 printk(" failed to detect IRQ line.\n");
477 ret = -EAGAIN;
478 goto err_out;
479 }
480
481 /* Snarf the interrupt now. There's no point in waiting since we cannot
482 share and the board will usually be enabled. */
483 ret = request_irq(dev->irq, ei_interrupt, 0, name, dev);
484 if (ret) {
485 printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
486 goto err_out;
487 }
488
489 dev->base_addr = ioaddr;
490
491#ifdef CONFIG_PLAT_MAPPI
492 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
493 ioaddr + E8390_CMD); /* 0x61 */
494 for (i = 0 ; i < ETHER_ADDR_LEN ; i++) {
495 dev->dev_addr[i] = SA_prom[i]
496 = inb_p(ioaddr + EN1_PHYS_SHIFT(i));
497 printk(" %2.2x", SA_prom[i]);
498 }
499#else
500 for(i = 0; i < ETHER_ADDR_LEN; i++) {
501 printk(" %2.2x", SA_prom[i]);
502 dev->dev_addr[i] = SA_prom[i];
503 }
504#endif
505
506 printk("\n%s: %s found at %#x, using IRQ %d.\n",
507 dev->name, name, ioaddr, dev->irq);
508
509 ei_status.name = name;
510 ei_status.tx_start_page = start_page;
511 ei_status.stop_page = stop_page;
9cc975e0
RB		 512#if defined(CONFIG_TOSHIBA_RBTX4927) || defined(CONFIG_TOSHIBA_RBTX4938)
513 wordlength = 1;
514#endif
515
1da177e4
LT		 516#ifdef CONFIG_PLAT_OAKS32R
517 ei_status.word16 = 0;
518#else
519 ei_status.word16 = (wordlength == 2);
520#endif
521
522 ei_status.rx_start_page = start_page + TX_PAGES;
523#ifdef PACKETBUF_MEMSIZE
524 /* Allow the packet buffer size to be overridden by know-it-alls. */
525 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
526#endif
527
528 ei_status.reset_8390 = &ne_reset_8390;
529 ei_status.block_input = &ne_block_input;
530 ei_status.block_output = &ne_block_output;
531 ei_status.get_8390_hdr = &ne_get_8390_hdr;
532 ei_status.priv = 0;
533 dev->open = &ne_open;
534 dev->stop = &ne_close;
535#ifdef CONFIG_NET_POLL_CONTROLLER
536 dev->poll_controller = ei_poll;
537#endif
538 NS8390_init(dev, 0);
b1fc5505
HX		 539
540 ret = register_netdev(dev);
541 if (ret)
542 goto out_irq;
1da177e4
LT		 543 return 0;
544
b1fc5505
HX		 545out_irq:
546 free_irq(dev->irq, dev);
1da177e4
LT		 547err_out:
548 release_region(ioaddr, NE_IO_EXTENT);
549 return ret;
550}
551
552static int ne_open(struct net_device *dev)
553{
554 ei_open(dev);
555 return 0;
556}
557
558static int ne_close(struct net_device *dev)
559{
560 if (ei_debug > 1)
561 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
562 ei_close(dev);
563 return 0;
564}
565
566/* Hard reset the card. This used to pause for the same period that a
567 8390 reset command required, but that shouldn't be necessary. */
568
569static void ne_reset_8390(struct net_device *dev)
570{
571 unsigned long reset_start_time = jiffies;
572
573 if (ei_debug > 1)
574 printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
575
576 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
577 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
578
579 ei_status.txing = 0;
580 ei_status.dmaing = 0;
581
582 /* This check _should_not_ be necessary, omit eventually. */
583 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
ff5688ae 584 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
1da177e4
LT		 585 printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", dev->name);
586 break;
587 }
588 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
589}
590
591/* Grab the 8390 specific header. Similar to the block_input routine, but
592 we don't need to be concerned with ring wrap as the header will be at
593 the start of a page, so we optimize accordingly. */
594
595static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
596{
597 int nic_base = dev->base_addr;
598
599 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
600
601 if (ei_status.dmaing)
602 {
603 printk(KERN_EMERG "%s: DMAing conflict in ne_get_8390_hdr "
604 "[DMAstat:%d][irqlock:%d].\n",
605 dev->name, ei_status.dmaing, ei_status.irqlock);
606 return;
607 }
608
609 ei_status.dmaing |= 0x01;
610 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
611 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
612 outb_p(0, nic_base + EN0_RCNTHI);
613 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
614 outb_p(ring_page, nic_base + EN0_RSARHI);
615 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
616
617 if (ei_status.word16)
618 insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
619 else
620 insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
621
622 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
623 ei_status.dmaing &= ~0x01;
624
625 le16_to_cpus(&hdr->count);
626}
627
628/* Block input and output, similar to the Crynwr packet driver. If you
629 are porting to a new ethercard, look at the packet driver source for hints.
630 The NEx000 doesn't share the on-board packet memory -- you have to put
631 the packet out through the "remote DMA" dataport using outb. */
632
633static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
634{
635#ifdef NE_SANITY_CHECK
636 int xfer_count = count;
637#endif
638 int nic_base = dev->base_addr;
639 char *buf = skb->data;
640
641 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
642 if (ei_status.dmaing)
643 {
644 printk(KERN_EMERG "%s: DMAing conflict in ne_block_input "
645 "[DMAstat:%d][irqlock:%d].\n",
646 dev->name, ei_status.dmaing, ei_status.irqlock);
647 return;
648 }
649 ei_status.dmaing |= 0x01;
650 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
651 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
652 outb_p(count >> 8, nic_base + EN0_RCNTHI);
653 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
654 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
655 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
656 if (ei_status.word16)
657 {
658 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
659 if (count & 0x01)
660 {
661 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
662#ifdef NE_SANITY_CHECK
663 xfer_count++;
664#endif
665 }
666 } else {
667 insb(NE_BASE + NE_DATAPORT, buf, count);
668 }
669
670#ifdef NE_SANITY_CHECK
671 /* This was for the ALPHA version only, but enough people have
672 been encountering problems so it is still here. If you see
673 this message you either 1) have a slightly incompatible clone
674 or 2) have noise/speed problems with your bus. */
675
676 if (ei_debug > 1)
677 {
678 /* DMA termination address check... */
679 int addr, tries = 20;
680 do {
681 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
682 -- it's broken for Rx on some cards! */
683 int high = inb_p(nic_base + EN0_RSARHI);
684 int low = inb_p(nic_base + EN0_RSARLO);
685 addr = (high << 8) + low;
686 if (((ring_offset + xfer_count) & 0xff) == low)
687 break;
688 } while (--tries > 0);
689 if (tries <= 0)
690 printk(KERN_WARNING "%s: RX transfer address mismatch,"
691 "%#4.4x (expected) vs. %#4.4x (actual).\n",
692 dev->name, ring_offset + xfer_count, addr);
693 }
694#endif
695 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
696 ei_status.dmaing &= ~0x01;
697}
698
699static void ne_block_output(struct net_device *dev, int count,
700 const unsigned char *buf, const int start_page)
701{
702 int nic_base = NE_BASE;
703 unsigned long dma_start;
704#ifdef NE_SANITY_CHECK
705 int retries = 0;
706#endif
707
708 /* Round the count up for word writes. Do we need to do this?
709 What effect will an odd byte count have on the 8390?
710 I should check someday. */
711
712 if (ei_status.word16 && (count & 0x01))
713 count++;
714
715 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
716 if (ei_status.dmaing)
717 {
718 printk(KERN_EMERG "%s: DMAing conflict in ne_block_output."
719 "[DMAstat:%d][irqlock:%d]\n",
720 dev->name, ei_status.dmaing, ei_status.irqlock);
721 return;
722 }
723 ei_status.dmaing |= 0x01;
724 /* We should already be in page 0, but to be safe... */
725 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
726
727#ifdef NE_SANITY_CHECK
728retry:
729#endif
730
731#ifdef NE8390_RW_BUGFIX
732 /* Handle the read-before-write bug the same way as the
733 Crynwr packet driver -- the NatSemi method doesn't work.
734 Actually this doesn't always work either, but if you have
735 problems with your NEx000 this is better than nothing! */
736
737 outb_p(0x42, nic_base + EN0_RCNTLO);
738 outb_p(0x00, nic_base + EN0_RCNTHI);
739 outb_p(0x42, nic_base + EN0_RSARLO);
740 outb_p(0x00, nic_base + EN0_RSARHI);
741 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
742 /* Make certain that the dummy read has occurred. */
743 udelay(6);
744#endif
745
746 outb_p(ENISR_RDC, nic_base + EN0_ISR);
747
748 /* Now the normal output. */
749 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
750 outb_p(count >> 8, nic_base + EN0_RCNTHI);
751 outb_p(0x00, nic_base + EN0_RSARLO);
752 outb_p(start_page, nic_base + EN0_RSARHI);
753
754 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
755 if (ei_status.word16) {
756 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
757 } else {
758 outsb(NE_BASE + NE_DATAPORT, buf, count);
759 }
760
761 dma_start = jiffies;
762
763#ifdef NE_SANITY_CHECK
764 /* This was for the ALPHA version only, but enough people have
765 been encountering problems so it is still here. */
766
767 if (ei_debug > 1)
768 {
769 /* DMA termination address check... */
770 int addr, tries = 20;
771 do {
772 int high = inb_p(nic_base + EN0_RSARHI);
773 int low = inb_p(nic_base + EN0_RSARLO);
774 addr = (high << 8) + low;
775 if ((start_page << 8) + count == addr)
776 break;
777 } while (--tries > 0);
778
779 if (tries <= 0)
780 {
781 printk(KERN_WARNING "%s: Tx packet transfer address mismatch,"
782 "%#4.4x (expected) vs. %#4.4x (actual).\n",
783 dev->name, (start_page << 8) + count, addr);
784 if (retries++ == 0)
785 goto retry;
786 }
787 }
788#endif
789
790 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
ff5688ae 791 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
1da177e4
LT		 792 printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
793 ne_reset_8390(dev);
794 NS8390_init(dev,1);
795 break;
796 }
797
798 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
799 ei_status.dmaing &= ~0x01;
800 return;
801}
802
803\f
804#ifdef MODULE
805#define MAX_NE_CARDS 4 /* Max number of NE cards per module */
806static struct net_device *dev_ne[MAX_NE_CARDS];
807static int io[MAX_NE_CARDS];
808static int irq[MAX_NE_CARDS];
809static int bad[MAX_NE_CARDS]; /* 0xbad = bad sig or no reset ack */
810
811module_param_array(io, int, NULL, 0);
812module_param_array(irq, int, NULL, 0);
813module_param_array(bad, int, NULL, 0);
814MODULE_PARM_DESC(io, "I/O base address(es),required");
815MODULE_PARM_DESC(irq, "IRQ number(s)");
816MODULE_PARM_DESC(bad, "Accept card(s) with bad signatures");
817MODULE_DESCRIPTION("NE1000/NE2000 ISA/PnP Ethernet driver");
818MODULE_LICENSE("GPL");
819
820/* This is set up so that no ISA autoprobe takes place. We can't guarantee
821that the ne2k probe is the last 8390 based probe to take place (as it
822is at boot) and so the probe will get confused by any other 8390 cards.
823ISA device autoprobes on a running machine are not recommended anyway. */
824
825int init_module(void)
826{
827 int this_dev, found = 0;
828
829 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
830 struct net_device *dev = alloc_ei_netdev();
831 if (!dev)
832 break;
833 dev->irq = irq[this_dev];
834 dev->mem_end = bad[this_dev];
835 dev->base_addr = io[this_dev];
836 if (do_ne_probe(dev) == 0) {
b1fc5505
HX		 837 dev_ne[found++] = dev;
838 continue;
1da177e4
LT		 839 }
840 free_netdev(dev);
841 if (found)
842 break;
843 if (io[this_dev] != 0)
844 printk(KERN_WARNING "ne.c: No NE*000 card found at i/o = %#x\n", io[this_dev]);
845 else
846 printk(KERN_NOTICE "ne.c: You must supply \"io=0xNNN\" value(s) for ISA cards.\n");
847 return -ENXIO;
848 }
849 if (found)
850 return 0;
851 return -ENODEV;
852}
853
64916f1e
DV		 854static void cleanup_card(struct net_device *dev)
855{
856 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
857 if (idev)
858 pnp_device_detach(idev);
859 free_irq(dev->irq, dev);
860 release_region(dev->base_addr, NE_IO_EXTENT);
861}
862
1da177e4
LT		 863void cleanup_module(void)
864{
865 int this_dev;
866
867 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
868 struct net_device *dev = dev_ne[this_dev];
869 if (dev) {
870 unregister_netdev(dev);
871 cleanup_card(dev);
872 free_netdev(dev);
873 }
874 }
875}
876#endif /* MODULE */
ubuntu-bionic-kernel mirror