![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ne.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to ne.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 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 Public License, incorporated herein by reference.
10:
11: The author may be reached as [email protected], or C/O
12: Center of Excellence in Space Data and Information Sciences
13: Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
14:
15: This driver should work with many programmed-I/O 8390-based ethernet
16: boards. Currently it supports the NE1000, NE2000, many clones,
17: and some Cabletron products.
18:
19: Changelog:
20:
21: Paul Gortmaker : use ENISR_RDC to monitor Tx PIO uploads, made
22: sanity checks and bad clone support optional.
23: Paul Gortmaker : new reset code, reset card after probe at boot.
24: Paul Gortmaker : multiple card support for module users.
25: Paul Gortmaker : Support for PCI ne2k clones, similar to lance.c
26: Paul Gortmaker : Allow users with bad cards to avoid full probe.
27: Paul Gortmaker : PCI probe changes, more PCI cards supported.
28:
29: */
30:
31: /* Routines for the NatSemi-based designs (NE[12]000). */
32:
33: static const char *version =
34: "ne.c:v1.10 9/23/94 Donald Becker ([email protected])\n";
35:
36:
37: #include <linux/module.h>
38: #include <linux/config.h>
39: #include <linux/kernel.h>
40: #include <linux/sched.h>
41: #include <linux/errno.h>
42: #include <linux/pci.h>
43: #include <linux/bios32.h>
44: #include <asm/system.h>
45: #include <asm/io.h>
46:
47: #include <linux/netdevice.h>
48: #include <linux/etherdevice.h>
49: #include "8390.h"
50:
51: /* Some defines that people can play with if so inclined. */
52:
53: /* Do we support clones that don't adhere to 14,15 of the SAprom ? */
54: #define SUPPORT_NE_BAD_CLONES
55:
56: /* Do we perform extra sanity checks on stuff ? */
57: /* #define NE_SANITY_CHECK */
58:
59: /* Do we implement the read before write bugfix ? */
60: /* #define NE_RW_BUGFIX */
61:
62: /* Do we have a non std. amount of memory? (in units of 256 byte pages) */
63: /* #define PACKETBUF_MEMSIZE 0x40 */
64:
65: #if defined(HAVE_DEVLIST) || !defined(MODULE)
66: /* A zero-terminated list of I/O addresses to be probed. */
67: static unsigned int netcard_portlist[] =
68: { 0x300, 0x280, 0x320, 0x340, 0x360, 0};
69: #endif /* defined(HAVE_DEVLIST) || !defined(MODULE) */
70:
71: #ifdef CONFIG_PCI
72: /* Ack! People are making PCI ne2000 clones! Oh the horror, the horror... */
73: static struct { unsigned short vendor, dev_id;}
74: pci_clone_list[] = {
75: {PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8029},
76: {PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_89C940},
77: {PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_RL2000},
78: {PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_ET32P2},
79: {PCI_VENDOR_ID_NETVIN, PCI_DEVICE_ID_NETVIN_NV5000SC},
80: {PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C926},
81: {0,}
82: };
83: #endif
84:
85: #ifdef SUPPORT_NE_BAD_CLONES
86: /* A list of bad clones that we none-the-less recognize. */
87: static struct { const char *name8, *name16; unsigned char SAprefix[4];}
88: bad_clone_list[] = {
89: {"DE100", "DE200", {0x00, 0xDE, 0x01,}},
90: {"DE120", "DE220", {0x00, 0x80, 0xc8,}},
91: {"DFI1000", "DFI2000", {'D', 'F', 'I',}}, /* Original, eh? */
92: {"EtherNext UTP8", "EtherNext UTP16", {0x00, 0x00, 0x79}},
93: {"NE1000","NE2000-invalid", {0x00, 0x00, 0xd8}}, /* Ancient real NE1000. */
94: {"NN1000", "NN2000", {0x08, 0x03, 0x08}}, /* Outlaw no-name clone. */
95: {"4-DIM8","4-DIM16", {0x00,0x00,0x4d,}}, /* Outlaw 4-Dimension cards. */
96: {"Con-Intl_8", "Con-Intl_16", {0x00, 0x00, 0x24}}, /* Connect Int'nl */
97: {"ET-100","ET-200", {0x00, 0x45, 0x54}}, /* YANG and YA clone */
98: {"COMPEX","COMPEX16",{0x00,0x80,0x48}}, /* Broken ISA Compex cards */
99: {"E-LAN100", "E-LAN200", {0x00, 0x00, 0x5d}}, /* Broken ne1000 clones */
100: {0,}
101: };
102: #endif
103:
104: /* ---- No user-serviceable parts below ---- */
105:
106: #define NE_BASE (dev->base_addr)
107: #define NE_CMD 0x00
108: #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
109: #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
110: #define NE_IO_EXTENT 0x20
111:
112: #define NE1SM_START_PG 0x20 /* First page of TX buffer */
113: #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
114: #define NESM_START_PG 0x40 /* First page of TX buffer */
115: #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
116:
117: /* Non-zero only if the current card is a PCI with BIOS-set IRQ. */
118: static unsigned char pci_irq_line = 0;
119:
120: int ne_probe(struct device *dev);
121: #ifdef CONFIG_PCI
122: static int ne_probe_pci(struct device *dev);
123: #endif
124: static int ne_probe1(struct device *dev, int ioaddr);
125:
126: static int ne_open(struct device *dev);
127: static int ne_close(struct device *dev);
128:
129: static void ne_reset_8390(struct device *dev);
130: static void ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
131: int ring_page);
132: static void ne_block_input(struct device *dev, int count,
133: struct sk_buff *skb, int ring_offset);
134: static void ne_block_output(struct device *dev, const int count,
135: const unsigned char *buf, const int start_page);
136:
137:
138: /* Probe for various non-shared-memory ethercards.
139:
140: NEx000-clone boards have a Station Address PROM (SAPROM) in the packet
141: buffer memory space. NE2000 clones have 0x57,0x57 in bytes 0x0e,0x0f of
142: the SAPROM, while other supposed NE2000 clones must be detected by their
143: SA prefix.
144:
145: Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
146: mode results in doubled values, which can be detected and compensated for.
147:
148: The probe is also responsible for initializing the card and filling
149: in the 'dev' and 'ei_status' structures.
150:
151: We use the minimum memory size for some ethercard product lines, iff we can't
152: distinguish models. You can increase the packet buffer size by setting
153: PACKETBUF_MEMSIZE. Reported Cabletron packet buffer locations are:
154: E1010 starts at 0x100 and ends at 0x2000.
155: E1010-x starts at 0x100 and ends at 0x8000. ("-x" means "more memory")
156: E2010 starts at 0x100 and ends at 0x4000.
157: E2010-x starts at 0x100 and ends at 0xffff. */
158:
159: #ifdef HAVE_DEVLIST
160: struct netdev_entry netcard_drv =
161: {"ne", ne_probe1, NE_IO_EXTENT, netcard_portlist};
162: #else
163:
164: /* Note that this probe only picks up one card at a time, even for multiple
165: PCI ne2k cards. Use "ether=0,0,eth1" if you have a second PCI ne2k card.
166: This keeps things consistent regardless of the bus type of the card. */
167:
168: int ne_probe(struct device *dev)
169: {
170: #ifndef MODULE
171: int i;
172: #endif /* MODULE */
173: int base_addr = dev ? dev->base_addr : 0;
174:
175: /* First check any supplied i/o locations. User knows best. <cough> */
176: if (base_addr > 0x1ff) /* Check a single specified location. */
177: return ne_probe1(dev, base_addr);
178: else if (base_addr != 0) /* Don't probe at all. */
179: return ENXIO;
180:
181: #ifdef CONFIG_PCI
182: /* Then look for any installed PCI clones */
183: if (pcibios_present() && (ne_probe_pci(dev) == 0))
184: return 0;
185: #endif
186:
187: #ifndef MODULE
188: /* Last resort. The semi-risky ISA auto-probe. */
189: for (i = 0; netcard_portlist[i]; i++) {
190: int ioaddr = netcard_portlist[i];
191: if (check_region(ioaddr, NE_IO_EXTENT))
192: continue;
193: if (ne_probe1(dev, ioaddr) == 0)
194: return 0;
195: }
196: #endif
197:
198: return ENODEV;
199: }
200: #endif
201:
202: #ifdef CONFIG_PCI
203: static int ne_probe_pci(struct device *dev)
204: {
205: int i;
206:
207: for (i = 0; pci_clone_list[i].vendor != 0; i++) {
208: unsigned char pci_bus, pci_device_fn;
209: unsigned int pci_ioaddr;
210: u16 pci_command, new_command;
211: int pci_index;
212:
213: for (pci_index = 0; pci_index < 8; pci_index++) {
214: if (pcibios_find_device (pci_clone_list[i].vendor,
215: pci_clone_list[i].dev_id, pci_index,
216: &pci_bus, &pci_device_fn) != 0)
217: break; /* No more of these type of cards */
218: pcibios_read_config_dword(pci_bus, pci_device_fn,
219: PCI_BASE_ADDRESS_0, &pci_ioaddr);
220: /* Strip the I/O address out of the returned value */
221: pci_ioaddr &= PCI_BASE_ADDRESS_IO_MASK;
222: /* Avoid already found cards from previous calls */
223: if (check_region(pci_ioaddr, NE_IO_EXTENT))
224: continue;
225: pcibios_read_config_byte(pci_bus, pci_device_fn,
226: PCI_INTERRUPT_LINE, &pci_irq_line);
227: break; /* Beauty -- got a valid card. */
228: }
229: if (pci_irq_line == 0) continue; /* Try next PCI ID */
230: printk("ne.c: PCI BIOS reports NE 2000 clone at i/o %#x, irq %d.\n",
231: pci_ioaddr, pci_irq_line);
232:
233: pcibios_read_config_word(pci_bus, pci_device_fn,
234: PCI_COMMAND, &pci_command);
235:
236: /* Activate the card: fix for brain-damaged Win98 BIOSes. */
237: new_command = pci_command | PCI_COMMAND_IO;
238: if (pci_command != new_command) {
239: printk(KERN_INFO " The PCI BIOS has not enabled this"
240: " NE2k clone! Updating PCI command %4.4x->%4.4x.\n",
241: pci_command, new_command);
242: pcibios_write_config_word(pci_bus, pci_device_fn,
243: PCI_COMMAND, new_command);
244: }
245:
246: if (ne_probe1(dev, pci_ioaddr) != 0) { /* Shouldn't happen. */
247: printk(KERN_ERR "ne.c: Probe of PCI card at %#x failed.\n", pci_ioaddr);
248: pci_irq_line = 0;
249: return -ENXIO;
250: }
251: pci_irq_line = 0;
252: return 0;
253: }
254: return -ENODEV;
255: }
256: #endif /* CONFIG_PCI */
257:
258: static int ne_probe1(struct device *dev, int ioaddr)
259: {
260: int i;
261: unsigned char SA_prom[32];
262: int wordlength = 2;
263: const char *name = NULL;
264: int start_page, stop_page;
265: int neX000, ctron, bad_card;
266: int reg0 = inb_p(ioaddr);
267: static unsigned version_printed = 0;
268:
269: if (reg0 == 0xFF)
270: return ENODEV;
271:
272: /* Do a preliminary verification that we have a 8390. */
273: { int regd;
274: outb_p(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
275: regd = inb_p(ioaddr + 0x0d);
276: outb_p(0xff, ioaddr + 0x0d);
277: outb_p(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
278: inb_p(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
279: if (inb_p(ioaddr + EN0_COUNTER0) != 0) {
280: outb_p(reg0, ioaddr);
281: outb_p(regd, ioaddr + 0x0d); /* Restore the old values. */
282: return ENODEV;
283: }
284: }
285:
286: /* We should have a "dev" from Space.c or the static module table. */
287: if (dev == NULL) {
288: printk(KERN_ERR "ne.c: Passed a NULL device.\n");
289: dev = init_etherdev(0, 0);
290: }
291:
292: if (ei_debug && version_printed++ == 0)
293: printk(version);
294:
295: printk("NE*000 ethercard probe at %#3x:", ioaddr);
296:
297: /* A user with a poor card that fails to ack the reset, or that
298: does not have a valid 0x57,0x57 signature can still use this
299: without having to recompile. Specifying an i/o address along
300: with an otherwise unused dev->mem_end value of "0xBAD" will
301: cause the driver to skip these parts of the probe. */
302:
303: bad_card = ((dev->base_addr != 0) && (dev->mem_end == 0xbad));
304:
305: /* Reset card. Who knows what dain-bramaged state it was left in. */
306: { unsigned long reset_start_time = jiffies;
307:
308: /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
309: outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
310:
311: while ((inb_p(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
312: if (jiffies - reset_start_time > 2*HZ/100) {
313: if (bad_card) {
314: printk(" (warning: no reset ack)");
315: break;
316: } else {
317: printk(" not found (no reset ack).\n");
318: return ENODEV;
319: }
320: }
321:
322: outb_p(0xff, ioaddr + EN0_ISR); /* Ack all intr. */
323: }
324:
325: /* Read the 16 bytes of station address PROM.
326: We must first initialize registers, similar to NS8390_init(eifdev, 0).
327: We can't reliably read the SAPROM address without this.
328: (I learned the hard way!). */
329: {
330: struct {unsigned char value, offset; } program_seq[] = {
331: {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
332: {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
333: {0x00, EN0_RCNTLO}, /* Clear the count regs. */
334: {0x00, EN0_RCNTHI},
335: {0x00, EN0_IMR}, /* Mask completion irq. */
336: {0xFF, EN0_ISR},
337: {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
338: {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
339: {32, EN0_RCNTLO},
340: {0x00, EN0_RCNTHI},
341: {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
342: {0x00, EN0_RSARHI},
343: {E8390_RREAD+E8390_START, E8390_CMD},
344: };
345: for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
346: outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
347:
348: }
349: for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
350: SA_prom[i] = inb(ioaddr + NE_DATAPORT);
351: SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
352: if (SA_prom[i] != SA_prom[i+1])
353: wordlength = 1;
354: }
355:
356: /* At this point, wordlength *only* tells us if the SA_prom is doubled
357: up or not because some broken PCI cards don't respect the byte-wide
358: request in program_seq above, and hence don't have doubled up values.
359: These broken cards would otherwise be detected as an ne1000. */
360:
361: if (wordlength == 2)
362: for (i = 0; i < 16; i++)
363: SA_prom[i] = SA_prom[i+i];
364:
365: if (pci_irq_line || ioaddr >= 0x400)
366: wordlength = 2; /* Catch broken PCI cards mentioned above. */
367:
368: if (wordlength == 2) {
369: /* We must set the 8390 for word mode. */
370: outb_p(0x49, ioaddr + EN0_DCFG);
371: start_page = NESM_START_PG;
372: stop_page = NESM_STOP_PG;
373: } else {
374: start_page = NE1SM_START_PG;
375: stop_page = NE1SM_STOP_PG;
376: }
377:
378: neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
379: ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
380:
381: /* Set up the rest of the parameters. */
382: if (neX000 || bad_card) {
383: name = (wordlength == 2) ? "NE2000" : "NE1000";
384: } else if (ctron) {
385: name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
386: start_page = 0x01;
387: stop_page = (wordlength == 2) ? 0x40 : 0x20;
388: } else {
389: #ifdef SUPPORT_NE_BAD_CLONES
390: /* Ack! Well, there might be a *bad* NE*000 clone there.
391: Check for total bogus addresses. */
392: for (i = 0; bad_clone_list[i].name8; i++) {
393: if (SA_prom[0] == bad_clone_list[i].SAprefix[0] &&
394: SA_prom[1] == bad_clone_list[i].SAprefix[1] &&
395: SA_prom[2] == bad_clone_list[i].SAprefix[2]) {
396: if (wordlength == 2) {
397: name = bad_clone_list[i].name16;
398: } else {
399: name = bad_clone_list[i].name8;
400: }
401: break;
402: }
403: }
404: if (bad_clone_list[i].name8 == NULL) {
405: printk(" not found (invalid signature %2.2x %2.2x).\n",
406: SA_prom[14], SA_prom[15]);
407: return ENXIO;
408: }
409: #else
410: printk(" not found.\n");
411: return ENXIO;
412: #endif
413:
414: }
415:
416: if (pci_irq_line)
417: dev->irq = pci_irq_line;
418:
419: if (dev->irq < 2) {
420: autoirq_setup(0);
421: outb_p(0x50, ioaddr + EN0_IMR); /* Enable one interrupt. */
422: outb_p(0x00, ioaddr + EN0_RCNTLO);
423: outb_p(0x00, ioaddr + EN0_RCNTHI);
424: outb_p(E8390_RREAD+E8390_START, ioaddr); /* Trigger it... */
425: outb_p(0x00, ioaddr + EN0_IMR); /* Mask it again. */
426: dev->irq = autoirq_report(0);
427: if (ei_debug > 2)
428: printk(" autoirq is %d\n", dev->irq);
429: } else if (dev->irq == 2)
430: /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
431: or don't know which one to set. */
432: dev->irq = 9;
433:
434: if (! dev->irq) {
435: printk(" failed to detect IRQ line.\n");
436: return EAGAIN;
437: }
438:
439: /* Snarf the interrupt now. There's no point in waiting since we cannot
440: share (with ISA cards) and the board will usually be enabled. */
441: {
442: int irqval = request_irq(dev->irq, ei_interrupt,
443: pci_irq_line ? SA_SHIRQ : 0, name, dev);
444: if (irqval) {
445: printk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval);
446: return EAGAIN;
447: }
448: }
449:
450: dev->base_addr = ioaddr;
451:
452: /* Allocate dev->priv and fill in 8390 specific dev fields. */
453: if (ethdev_init(dev)) {
454: printk (" unable to get memory for dev->priv.\n");
455: free_irq(dev->irq, NULL);
456: return -ENOMEM;
457: }
458:
459: request_region(ioaddr, NE_IO_EXTENT, name);
460:
461: for(i = 0; i < ETHER_ADDR_LEN; i++) {
462: printk(" %2.2x", SA_prom[i]);
463: dev->dev_addr[i] = SA_prom[i];
464: }
465:
466: printk("\n%s: %s found at %#x, using IRQ %d.\n",
467: dev->name, name, ioaddr, dev->irq);
468:
469: ei_status.name = name;
470: ei_status.tx_start_page = start_page;
471: ei_status.stop_page = stop_page;
472: ei_status.word16 = (wordlength == 2);
473:
474: ei_status.rx_start_page = start_page + TX_PAGES;
475: #ifdef PACKETBUF_MEMSIZE
476: /* Allow the packet buffer size to be overridden by know-it-alls. */
477: ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
478: #endif
479:
480: ei_status.reset_8390 = &ne_reset_8390;
481: ei_status.block_input = &ne_block_input;
482: ei_status.block_output = &ne_block_output;
483: ei_status.get_8390_hdr = &ne_get_8390_hdr;
484: dev->open = &ne_open;
485: dev->stop = &ne_close;
486: NS8390_init(dev, 0);
487: return 0;
488: }
489:
490: static int
491: ne_open(struct device *dev)
492: {
493: ei_open(dev);
494: MOD_INC_USE_COUNT;
495: return 0;
496: }
497:
498: static int
499: ne_close(struct device *dev)
500: {
501: if (ei_debug > 1)
502: printk("%s: Shutting down ethercard.\n", dev->name);
503: ei_close(dev);
504: MOD_DEC_USE_COUNT;
505: return 0;
506: }
507:
508: /* Hard reset the card. This used to pause for the same period that a
509: 8390 reset command required, but that shouldn't be necessary. */
510: static void
511: ne_reset_8390(struct device *dev)
512: {
513: unsigned long reset_start_time = jiffies;
514:
515: if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
516:
517: /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
518: outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
519:
520: ei_status.txing = 0;
521: ei_status.dmaing = 0;
522:
523: /* This check _should_not_ be necessary, omit eventually. */
524: while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
525: if (jiffies - reset_start_time > 2*HZ/100) {
526: printk("%s: ne_reset_8390() did not complete.\n", dev->name);
527: break;
528: }
529: outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
530: }
531:
532: /* Grab the 8390 specific header. Similar to the block_input routine, but
533: we don't need to be concerned with ring wrap as the header will be at
534: the start of a page, so we optimize accordingly. */
535:
536: static void
537: ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
538: {
539:
540: int nic_base = dev->base_addr;
541:
542: /* This *shouldn't* happen. If it does, it's the last thing you'll see */
543: if (ei_status.dmaing) {
544: printk("%s: DMAing conflict in ne_get_8390_hdr "
545: "[DMAstat:%d][irqlock:%d][intr:%d].\n",
546: dev->name, ei_status.dmaing, ei_status.irqlock,
547: dev->interrupt);
548: return;
549: }
550:
551: ei_status.dmaing |= 0x01;
552: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
553: outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
554: outb_p(0, nic_base + EN0_RCNTHI);
555: outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
556: outb_p(ring_page, nic_base + EN0_RSARHI);
557: outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
558:
559: if (ei_status.word16)
560: insw(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
561: else
562: insb(NE_BASE + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
563:
564: outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
565: ei_status.dmaing &= ~0x01;
566: }
567:
568: /* Block input and output, similar to the Crynwr packet driver. If you
569: are porting to a new ethercard, look at the packet driver source for hints.
570: The NEx000 doesn't share the on-board packet memory -- you have to put
571: the packet out through the "remote DMA" dataport using outb. */
572:
573: static void
574: ne_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
575: {
576: #ifdef NE_SANITY_CHECK
577: int xfer_count = count;
578: #endif
579: int nic_base = dev->base_addr;
580: char *buf = skb->data;
581:
582: /* This *shouldn't* happen. If it does, it's the last thing you'll see */
583: if (ei_status.dmaing) {
584: printk("%s: DMAing conflict in ne_block_input "
585: "[DMAstat:%d][irqlock:%d][intr:%d].\n",
586: dev->name, ei_status.dmaing, ei_status.irqlock,
587: dev->interrupt);
588: return;
589: }
590: ei_status.dmaing |= 0x01;
591: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
592: outb_p(count & 0xff, nic_base + EN0_RCNTLO);
593: outb_p(count >> 8, nic_base + EN0_RCNTHI);
594: outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
595: outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
596: outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
597: if (ei_status.word16) {
598: insw(NE_BASE + NE_DATAPORT,buf,count>>1);
599: if (count & 0x01) {
600: buf[count-1] = inb(NE_BASE + NE_DATAPORT);
601: #ifdef NE_SANITY_CHECK
602: xfer_count++;
603: #endif
604: }
605: } else {
606: insb(NE_BASE + NE_DATAPORT, buf, count);
607: }
608:
609: #ifdef NE_SANITY_CHECK
610: /* This was for the ALPHA version only, but enough people have
611: been encountering problems so it is still here. If you see
612: this message you either 1) have a slightly incompatible clone
613: or 2) have noise/speed problems with your bus. */
614: if (ei_debug > 1) { /* DMA termination address check... */
615: int addr, tries = 20;
616: do {
617: /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
618: -- it's broken for Rx on some cards! */
619: int high = inb_p(nic_base + EN0_RSARHI);
620: int low = inb_p(nic_base + EN0_RSARLO);
621: addr = (high << 8) + low;
622: if (((ring_offset + xfer_count) & 0xff) == low)
623: break;
624: } while (--tries > 0);
625: if (tries <= 0)
626: printk("%s: RX transfer address mismatch,"
627: "%#4.4x (expected) vs. %#4.4x (actual).\n",
628: dev->name, ring_offset + xfer_count, addr);
629: }
630: #endif
631: outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
632: ei_status.dmaing &= ~0x01;
633: }
634:
635: static void
636: ne_block_output(struct device *dev, int count,
637: const unsigned char *buf, const int start_page)
638: {
639: int nic_base = NE_BASE;
640: unsigned long dma_start;
641: #ifdef NE_SANITY_CHECK
642: int retries = 0;
643: #endif
644:
645: /* Round the count up for word writes. Do we need to do this?
646: What effect will an odd byte count have on the 8390?
647: I should check someday. */
648: if (ei_status.word16 && (count & 0x01))
649: count++;
650:
651: /* This *shouldn't* happen. If it does, it's the last thing you'll see */
652: if (ei_status.dmaing) {
653: printk("%s: DMAing conflict in ne_block_output."
654: "[DMAstat:%d][irqlock:%d][intr:%d]\n",
655: dev->name, ei_status.dmaing, ei_status.irqlock,
656: dev->interrupt);
657: return;
658: }
659: ei_status.dmaing |= 0x01;
660: /* We should already be in page 0, but to be safe... */
661: outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
662:
663: #ifdef NE_SANITY_CHECK
664: retry:
665: #endif
666:
667: #ifdef NE8390_RW_BUGFIX
668: /* Handle the read-before-write bug the same way as the
669: Crynwr packet driver -- the NatSemi method doesn't work.
670: Actually this doesn't always work either, but if you have
671: problems with your NEx000 this is better than nothing! */
672: outb_p(0x42, nic_base + EN0_RCNTLO);
673: outb_p(0x00, nic_base + EN0_RCNTHI);
674: outb_p(0x42, nic_base + EN0_RSARLO);
675: outb_p(0x00, nic_base + EN0_RSARHI);
676: outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
677: /* Make certain that the dummy read has occurred. */
678: SLOW_DOWN_IO;
679: SLOW_DOWN_IO;
680: SLOW_DOWN_IO;
681: #endif
682:
683: outb_p(ENISR_RDC, nic_base + EN0_ISR);
684:
685: /* Now the normal output. */
686: outb_p(count & 0xff, nic_base + EN0_RCNTLO);
687: outb_p(count >> 8, nic_base + EN0_RCNTHI);
688: outb_p(0x00, nic_base + EN0_RSARLO);
689: outb_p(start_page, nic_base + EN0_RSARHI);
690:
691: outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
692: if (ei_status.word16) {
693: outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
694: } else {
695: outsb(NE_BASE + NE_DATAPORT, buf, count);
696: }
697:
698: dma_start = jiffies;
699:
700: #ifdef NE_SANITY_CHECK
701: /* This was for the ALPHA version only, but enough people have
702: been encountering problems so it is still here. */
703: if (ei_debug > 1) { /* DMA termination address check... */
704: int addr, tries = 20;
705: do {
706: int high = inb_p(nic_base + EN0_RSARHI);
707: int low = inb_p(nic_base + EN0_RSARLO);
708: addr = (high << 8) + low;
709: if ((start_page << 8) + count == addr)
710: break;
711: } while (--tries > 0);
712: if (tries <= 0) {
713: printk("%s: Tx packet transfer address mismatch,"
714: "%#4.4x (expected) vs. %#4.4x (actual).\n",
715: dev->name, (start_page << 8) + count, addr);
716: if (retries++ == 0)
717: goto retry;
718: }
719: }
720: #endif
721:
722: while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
723: if (jiffies - dma_start > 2*HZ/100) { /* 20ms */
724: printk("%s: timeout waiting for Tx RDC.\n", dev->name);
725: ne_reset_8390(dev);
726: NS8390_init(dev,1);
727: break;
728: }
729:
730: outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
731: ei_status.dmaing &= ~0x01;
732: return;
733: }
734:
735:
736: #ifdef MODULE
737: #define MAX_NE_CARDS 4 /* Max number of NE cards per module */
738: #define NAMELEN 8 /* # of chars for storing dev->name */
739: static char namelist[NAMELEN * MAX_NE_CARDS] = { 0, };
740: static struct device dev_ne[MAX_NE_CARDS] = {
741: {
742: NULL, /* assign a chunk of namelist[] below */
743: 0, 0, 0, 0,
744: 0, 0,
745: 0, 0, 0, NULL, NULL
746: },
747: };
748:
749: static int io[MAX_NE_CARDS] = { 0, };
750: static int irq[MAX_NE_CARDS] = { 0, };
751: static int bad[MAX_NE_CARDS] = { 0, };
752:
753: /* This is set up so that no autoprobe takes place. We can't guarantee
754: that the ne2k probe is the last 8390 based probe to take place (as it
755: is at boot) and so the probe will get confused by any other 8390 cards.
756: ISA device autoprobes on a running machine are not recommended anyway. */
757:
758: int
759: init_module(void)
760: {
761: int this_dev, found = 0;
762:
763: for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
764: struct device *dev = &dev_ne[this_dev];
765: dev->name = namelist+(NAMELEN*this_dev);
766: dev->irq = irq[this_dev];
767: dev->base_addr = io[this_dev];
768: dev->init = ne_probe;
769: dev->mem_end = bad[this_dev];
770: if (register_netdev(dev) == 0) {
771: found++;
772: continue;
773: }
774: if (found != 0) /* Got at least one. */
775: return 0;
776: if (io[this_dev] != 0)
777: printk(KERN_WARNING "ne.c: No NE*000 card found at i/o = %#x\n", io[this_dev]);
778: else
779: printk(KERN_NOTICE "ne.c: No PCI cards found. Use \"io=0xNNN\" value(s) for ISA cards.\n");
780: return -ENXIO;
781: }
782:
783: return 0;
784: }
785:
786: void
787: cleanup_module(void)
788: {
789: int this_dev;
790:
791: for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
792: struct device *dev = &dev_ne[this_dev];
793: if (dev->priv != NULL) {
794: kfree(dev->priv);
795: dev->priv = NULL;
796: free_irq(dev->irq, dev);
797: irq2dev_map[dev->irq] = NULL;
798: release_region(dev->base_addr, NE_IO_EXTENT);
799: unregister_netdev(dev);
800: }
801: }
802: }
803: #endif /* MODULE */
804:
805: /*
806: * Local variables:
807: * compile-command: "gcc -DKERNEL -Wall -O6 -fomit-frame-pointer -I/usr/src/linux/net/tcp -c ne.c"
808: * version-control: t
809: * kept-new-versions: 5
810: * End:
811: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.