ia64/linux-2.6.18-xen.hg

view drivers/net/ne2.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /* ne2.c: A NE/2 Ethernet Driver for Linux. */
2 /*
3 Based on the NE2000 driver written by Donald Becker (1992-94).
4 modified by Wim Dumon (Apr 1996)
6 This software may be used and distributed according to the terms
7 of the GNU General Public License, incorporated herein by reference.
9 The author may be reached as wimpie@linux.cc.kuleuven.ac.be
11 Currently supported: NE/2
12 This patch was never tested on other MCA-ethernet adapters, but it
13 might work. Just give it a try and let me know if you have problems.
14 Also mail me if it really works, please!
16 Changelog:
17 Mon Feb 3 16:26:02 MET 1997
18 - adapted the driver to work with the 2.1.25 kernel
19 - multiple ne2 support (untested)
20 - module support (untested)
22 Fri Aug 28 00:18:36 CET 1998 (David Weinehall)
23 - fixed a few minor typos
24 - made the MODULE_PARM conditional (it only works with the v2.1.x kernels)
25 - fixed the module support (Now it's working...)
27 Mon Sep 7 19:01:44 CET 1998 (David Weinehall)
28 - added support for Arco Electronics AE/2-card (experimental)
30 Mon Sep 14 09:53:42 CET 1998 (David Weinehall)
31 - added support for Compex ENET-16MC/P (experimental)
33 Tue Sep 15 16:21:12 CET 1998 (David Weinehall, Magnus Jonsson, Tomas Ogren)
34 - Miscellaneous bugfixes
36 Tue Sep 19 16:21:12 CET 1998 (Magnus Jonsson)
37 - Cleanup
39 Wed Sep 23 14:33:34 CET 1998 (David Weinehall)
40 - Restructuring and rewriting for v2.1.x compliance
42 Wed Oct 14 17:19:21 CET 1998 (David Weinehall)
43 - Added code that unregisters irq and proc-info
44 - Version# bump
46 Mon Nov 16 15:28:23 CET 1998 (Wim Dumon)
47 - pass 'dev' as last parameter of request_irq in stead of 'NULL'
49 Wed Feb 7 21:24:00 CET 2001 (Alfred Arnold)
50 - added support for the D-Link DE-320CT
52 * WARNING
53 -------
54 This is alpha-test software. It is not guaranteed to work. As a
55 matter of fact, I'm quite sure there are *LOTS* of bugs in here. I
56 would like to hear from you if you use this driver, even if it works.
57 If it doesn't work, be sure to send me a mail with the problems !
58 */
60 static const char *version = "ne2.c:v0.91 Nov 16 1998 Wim Dumon <wimpie@kotnet.org>\n";
62 #include <linux/module.h>
63 #include <linux/kernel.h>
64 #include <linux/types.h>
65 #include <linux/fcntl.h>
66 #include <linux/interrupt.h>
67 #include <linux/ioport.h>
68 #include <linux/in.h>
69 #include <linux/slab.h>
70 #include <linux/string.h>
71 #include <linux/errno.h>
72 #include <linux/init.h>
73 #include <linux/mca-legacy.h>
74 #include <linux/netdevice.h>
75 #include <linux/etherdevice.h>
76 #include <linux/skbuff.h>
77 #include <linux/bitops.h>
78 #include <linux/jiffies.h>
80 #include <asm/system.h>
81 #include <asm/io.h>
82 #include <asm/dma.h>
84 #include "8390.h"
86 #define DRV_NAME "ne2"
88 /* Some defines that people can play with if so inclined. */
90 /* Do we perform extra sanity checks on stuff ? */
91 /* #define NE_SANITY_CHECK */
93 /* Do we implement the read before write bugfix ? */
94 /* #define NE_RW_BUGFIX */
96 /* Do we have a non std. amount of memory? (in units of 256 byte pages) */
97 /* #define PACKETBUF_MEMSIZE 0x40 */
100 /* ---- No user-serviceable parts below ---- */
102 #define NE_BASE (dev->base_addr)
103 #define NE_CMD 0x00
104 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
105 #define NE_RESET 0x20 /* Issue a read to reset, a write to clear. */
106 #define NE_IO_EXTENT 0x30
108 #define NE1SM_START_PG 0x20 /* First page of TX buffer */
109 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
110 #define NESM_START_PG 0x40 /* First page of TX buffer */
111 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
113 /* From the .ADF file: */
114 static unsigned int addresses[7] __initdata =
115 {0x1000, 0x2020, 0x8020, 0xa0a0, 0xb0b0, 0xc0c0, 0xc3d0};
116 static int irqs[4] __initdata = {3, 4, 5, 9};
118 /* From the D-Link ADF file: */
119 static unsigned int dlink_addresses[4] __initdata =
120 {0x300, 0x320, 0x340, 0x360};
121 static int dlink_irqs[8] __initdata = {3, 4, 5, 9, 10, 11, 14, 15};
123 struct ne2_adapters_t {
124 unsigned int id;
125 char *name;
126 };
128 static struct ne2_adapters_t ne2_adapters[] __initdata = {
129 { 0x6354, "Arco Ethernet Adapter AE/2" },
130 { 0x70DE, "Compex ENET-16 MC/P" },
131 { 0x7154, "Novell Ethernet Adapter NE/2" },
132 { 0x56ea, "D-Link DE-320CT" },
133 { 0x0000, NULL }
134 };
136 extern int netcard_probe(struct net_device *dev);
138 static int ne2_probe1(struct net_device *dev, int slot);
140 static int ne_open(struct net_device *dev);
141 static int ne_close(struct net_device *dev);
143 static void ne_reset_8390(struct net_device *dev);
144 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
145 int ring_page);
146 static void ne_block_input(struct net_device *dev, int count,
147 struct sk_buff *skb, int ring_offset);
148 static void ne_block_output(struct net_device *dev, const int count,
149 const unsigned char *buf, const int start_page);
152 /*
153 * special code to read the DE-320's MAC address EEPROM. In contrast to a
154 * standard NE design, this is a serial EEPROM (93C46) that has to be read
155 * bit by bit. The EEPROM cotrol port at base + 0x1e has the following
156 * layout:
157 *
158 * Bit 0 = Data out (read from EEPROM)
159 * Bit 1 = Data in (write to EEPROM)
160 * Bit 2 = Clock
161 * Bit 3 = Chip Select
162 * Bit 7 = ~50 kHz clock for defined delays
163 *
164 */
166 static void __init dlink_put_eeprom(unsigned char value, unsigned int addr)
167 {
168 int z;
169 unsigned char v1, v2;
171 /* write the value to the NIC EEPROM register */
173 outb(value, addr + 0x1e);
175 /* now wait the clock line to toggle twice. Effectively, we are
176 waiting (at least) for one clock cycle */
178 for (z = 0; z < 2; z++) {
179 do {
180 v1 = inb(addr + 0x1e);
181 v2 = inb(addr + 0x1e);
182 }
183 while (!((v1 ^ v2) & 0x80));
184 }
185 }
187 static void __init dlink_send_eeprom_bit(unsigned int bit, unsigned int addr)
188 {
189 /* shift data bit into correct position */
191 bit = bit << 1;
193 /* write value, keep clock line high for two cycles */
195 dlink_put_eeprom(0x09 | bit, addr);
196 dlink_put_eeprom(0x0d | bit, addr);
197 dlink_put_eeprom(0x0d | bit, addr);
198 dlink_put_eeprom(0x09 | bit, addr);
199 }
201 static void __init dlink_send_eeprom_word(unsigned int value, unsigned int len, unsigned int addr)
202 {
203 int z;
205 /* adjust bits so that they are left-aligned in a 16-bit-word */
207 value = value << (16 - len);
209 /* shift bits out to the EEPROM */
211 for (z = 0; z < len; z++) {
212 dlink_send_eeprom_bit((value & 0x8000) >> 15, addr);
213 value = value << 1;
214 }
215 }
217 static unsigned int __init dlink_get_eeprom(unsigned int eeaddr, unsigned int addr)
218 {
219 int z;
220 unsigned int value = 0;
222 /* pull the CS line low for a moment. This resets the EEPROM-
223 internal logic, and makes it ready for a new command. */
225 dlink_put_eeprom(0x01, addr);
226 dlink_put_eeprom(0x09, addr);
228 /* send one start bit, read command (1 - 0), plus the address to
229 the EEPROM */
231 dlink_send_eeprom_word(0x0180 | (eeaddr & 0x3f), 9, addr);
233 /* get the data word. We clock by sending 0s to the EEPROM, which
234 get ignored during the read process */
236 for (z = 0; z < 16; z++) {
237 dlink_send_eeprom_bit(0, addr);
238 value = (value << 1) | (inb(addr + 0x1e) & 0x01);
239 }
241 return value;
242 }
244 /*
245 * Note that at boot, this probe only picks up one card at a time.
246 */
248 static int __init do_ne2_probe(struct net_device *dev)
249 {
250 static int current_mca_slot = -1;
251 int i;
252 int adapter_found = 0;
254 SET_MODULE_OWNER(dev);
256 /* Do not check any supplied i/o locations.
257 POS registers usually don't fail :) */
259 /* MCA cards have POS registers.
260 Autodetecting MCA cards is extremely simple.
261 Just search for the card. */
263 for(i = 0; (ne2_adapters[i].name != NULL) && !adapter_found; i++) {
264 current_mca_slot =
265 mca_find_unused_adapter(ne2_adapters[i].id, 0);
267 if((current_mca_slot != MCA_NOTFOUND) && !adapter_found) {
268 int res;
269 mca_set_adapter_name(current_mca_slot,
270 ne2_adapters[i].name);
271 mca_mark_as_used(current_mca_slot);
273 res = ne2_probe1(dev, current_mca_slot);
274 if (res)
275 mca_mark_as_unused(current_mca_slot);
276 return res;
277 }
278 }
279 return -ENODEV;
280 }
282 #ifndef MODULE
283 struct net_device * __init ne2_probe(int unit)
284 {
285 struct net_device *dev = alloc_ei_netdev();
286 int err;
288 if (!dev)
289 return ERR_PTR(-ENOMEM);
291 sprintf(dev->name, "eth%d", unit);
292 netdev_boot_setup_check(dev);
294 err = do_ne2_probe(dev);
295 if (err)
296 goto out;
297 return dev;
298 out:
299 free_netdev(dev);
300 return ERR_PTR(err);
301 }
302 #endif
304 static int ne2_procinfo(char *buf, int slot, struct net_device *dev)
305 {
306 int len=0;
308 len += sprintf(buf+len, "The NE/2 Ethernet Adapter\n" );
309 len += sprintf(buf+len, "Driver written by Wim Dumon ");
310 len += sprintf(buf+len, "<wimpie@kotnet.org>\n");
311 len += sprintf(buf+len, "Modified by ");
312 len += sprintf(buf+len, "David Weinehall <tao@acc.umu.se>\n");
313 len += sprintf(buf+len, "and by Magnus Jonsson <bigfoot@acc.umu.se>\n");
314 len += sprintf(buf+len, "Based on the original NE2000 drivers\n" );
315 len += sprintf(buf+len, "Base IO: %#x\n", (unsigned int)dev->base_addr);
316 len += sprintf(buf+len, "IRQ : %d\n", dev->irq);
318 #define HW_ADDR(i) dev->dev_addr[i]
319 len += sprintf(buf+len, "HW addr : %x:%x:%x:%x:%x:%x\n",
320 HW_ADDR(0), HW_ADDR(1), HW_ADDR(2),
321 HW_ADDR(3), HW_ADDR(4), HW_ADDR(5) );
322 #undef HW_ADDR
324 return len;
325 }
327 static int __init ne2_probe1(struct net_device *dev, int slot)
328 {
329 int i, base_addr, irq, retval;
330 unsigned char POS;
331 unsigned char SA_prom[32];
332 const char *name = "NE/2";
333 int start_page, stop_page;
334 static unsigned version_printed;
336 if (ei_debug && version_printed++ == 0)
337 printk(version);
339 printk("NE/2 ethercard found in slot %d:", slot);
341 /* Read base IO and IRQ from the POS-registers */
342 POS = mca_read_stored_pos(slot, 2);
343 if(!(POS % 2)) {
344 printk(" disabled.\n");
345 return -ENODEV;
346 }
348 /* handle different POS register structure for D-Link card */
350 if (mca_read_stored_pos(slot, 0) == 0xea) {
351 base_addr = dlink_addresses[(POS >> 5) & 0x03];
352 irq = dlink_irqs[(POS >> 2) & 0x07];
353 }
354 else {
355 i = (POS & 0xE)>>1;
356 /* printk("Halleluja sdog, als er na de pijl een 1 staat is 1 - 1 == 0"
357 " en zou het moeten werken -> %d\n", i);
358 The above line was for remote testing, thanx to sdog ... */
359 base_addr = addresses[i - 1];
360 irq = irqs[(POS & 0x60)>>5];
361 }
363 if (!request_region(base_addr, NE_IO_EXTENT, DRV_NAME))
364 return -EBUSY;
366 #ifdef DEBUG
367 printk("POS info : pos 2 = %#x ; base = %#x ; irq = %ld\n", POS,
368 base_addr, irq);
369 #endif
371 #ifndef CRYNWR_WAY
372 /* Reset the card the way they do it in the Crynwr packet driver */
373 for (i=0; i<8; i++)
374 outb(0x0, base_addr + NE_RESET);
375 inb(base_addr + NE_RESET);
376 outb(0x21, base_addr + NE_CMD);
377 if (inb(base_addr + NE_CMD) != 0x21) {
378 printk("NE/2 adapter not responding\n");
379 retval = -ENODEV;
380 goto out;
381 }
383 /* In the crynwr sources they do a RAM-test here. I skip it. I suppose
384 my RAM is okay. Suppose your memory is broken. Then this test
385 should fail and you won't be able to use your card. But if I do not
386 test, you won't be able to use your card, neither. So this test
387 won't help you. */
389 #else /* _I_ never tested it this way .. Go ahead and try ...*/
390 /* Reset card. Who knows what dain-bramaged state it was left in. */
391 {
392 unsigned long reset_start_time = jiffies;
394 /* DON'T change these to inb_p/outb_p or reset will fail on
395 clones.. */
396 outb(inb(base_addr + NE_RESET), base_addr + NE_RESET);
398 while ((inb_p(base_addr + EN0_ISR) & ENISR_RESET) == 0)
399 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
400 printk(" not found (no reset ack).\n");
401 retval = -ENODEV;
402 goto out;
403 }
405 outb_p(0xff, base_addr + EN0_ISR); /* Ack all intr. */
406 }
407 #endif
410 /* Read the 16 bytes of station address PROM.
411 We must first initialize registers, similar to
412 NS8390_init(eifdev, 0).
413 We can't reliably read the SAPROM address without this.
414 (I learned the hard way!). */
415 {
416 struct {
417 unsigned char value, offset;
418 } program_seq[] = {
419 /* Select page 0 */
420 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD},
421 {0x49, EN0_DCFG}, /* Set WORD-wide (0x49) access. */
422 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
423 {0x00, EN0_RCNTHI},
424 {0x00, EN0_IMR}, /* Mask completion irq. */
425 {0xFF, EN0_ISR},
426 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
427 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
428 {32, EN0_RCNTLO},
429 {0x00, EN0_RCNTHI},
430 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
431 {0x00, EN0_RSARHI},
432 {E8390_RREAD+E8390_START, E8390_CMD},
433 };
435 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
436 outb_p(program_seq[i].value, base_addr +
437 program_seq[i].offset);
439 }
440 for(i = 0; i < 6 /*sizeof(SA_prom)*/; i+=1) {
441 SA_prom[i] = inb(base_addr + NE_DATAPORT);
442 }
444 /* I don't know whether the previous sequence includes the general
445 board reset procedure, so better don't omit it and just overwrite
446 the garbage read from a DE-320 with correct stuff. */
448 if (mca_read_stored_pos(slot, 0) == 0xea) {
449 unsigned int v;
451 for (i = 0; i < 3; i++) {
452 v = dlink_get_eeprom(i, base_addr);
453 SA_prom[(i << 1) ] = v & 0xff;
454 SA_prom[(i << 1) + 1] = (v >> 8) & 0xff;
455 }
456 }
458 start_page = NESM_START_PG;
459 stop_page = NESM_STOP_PG;
461 dev->irq=irq;
463 /* Snarf the interrupt now. There's no point in waiting since we cannot
464 share and the board will usually be enabled. */
465 retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
466 if (retval) {
467 printk (" unable to get IRQ %d (irqval=%d).\n",
468 dev->irq, retval);
469 goto out;
470 }
472 dev->base_addr = base_addr;
474 for(i = 0; i < ETHER_ADDR_LEN; i++) {
475 printk(" %2.2x", SA_prom[i]);
476 dev->dev_addr[i] = SA_prom[i];
477 }
479 printk("\n%s: %s found at %#x, using IRQ %d.\n",
480 dev->name, name, base_addr, dev->irq);
482 mca_set_adapter_procfn(slot, (MCA_ProcFn) ne2_procinfo, dev);
484 ei_status.name = name;
485 ei_status.tx_start_page = start_page;
486 ei_status.stop_page = stop_page;
487 ei_status.word16 = (2 == 2);
489 ei_status.rx_start_page = start_page + TX_PAGES;
490 #ifdef PACKETBUF_MEMSIZE
491 /* Allow the packet buffer size to be overridden by know-it-alls. */
492 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
493 #endif
495 ei_status.reset_8390 = &ne_reset_8390;
496 ei_status.block_input = &ne_block_input;
497 ei_status.block_output = &ne_block_output;
498 ei_status.get_8390_hdr = &ne_get_8390_hdr;
500 ei_status.priv = slot;
502 dev->open = &ne_open;
503 dev->stop = &ne_close;
504 #ifdef CONFIG_NET_POLL_CONTROLLER
505 dev->poll_controller = ei_poll;
506 #endif
507 NS8390_init(dev, 0);
509 retval = register_netdev(dev);
510 if (retval)
511 goto out1;
512 return 0;
513 out1:
514 mca_set_adapter_procfn( ei_status.priv, NULL, NULL);
515 free_irq(dev->irq, dev);
516 out:
517 release_region(base_addr, NE_IO_EXTENT);
518 return retval;
519 }
521 static int ne_open(struct net_device *dev)
522 {
523 ei_open(dev);
524 return 0;
525 }
527 static int ne_close(struct net_device *dev)
528 {
529 if (ei_debug > 1)
530 printk("%s: Shutting down ethercard.\n", dev->name);
531 ei_close(dev);
532 return 0;
533 }
535 /* Hard reset the card. This used to pause for the same period that a
536 8390 reset command required, but that shouldn't be necessary. */
537 static void ne_reset_8390(struct net_device *dev)
538 {
539 unsigned long reset_start_time = jiffies;
541 if (ei_debug > 1)
542 printk("resetting the 8390 t=%ld...", jiffies);
544 /* DON'T change these to inb_p/outb_p or reset will fail on clones. */
545 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
547 ei_status.txing = 0;
548 ei_status.dmaing = 0;
550 /* This check _should_not_ be necessary, omit eventually. */
551 while ((inb_p(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
552 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
553 printk("%s: ne_reset_8390() did not complete.\n",
554 dev->name);
555 break;
556 }
557 outb_p(ENISR_RESET, NE_BASE + EN0_ISR); /* Ack intr. */
558 }
560 /* Grab the 8390 specific header. Similar to the block_input routine, but
561 we don't need to be concerned with ring wrap as the header will be at
562 the start of a page, so we optimize accordingly. */
564 static void ne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
565 int ring_page)
566 {
568 int nic_base = dev->base_addr;
570 /* This *shouldn't* happen.
571 If it does, it's the last thing you'll see */
572 if (ei_status.dmaing) {
573 printk("%s: DMAing conflict in ne_get_8390_hdr "
574 "[DMAstat:%d][irqlock:%d].\n",
575 dev->name, ei_status.dmaing, ei_status.irqlock);
576 return;
577 }
579 ei_status.dmaing |= 0x01;
580 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
581 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
582 outb_p(0, nic_base + EN0_RCNTHI);
583 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
584 outb_p(ring_page, nic_base + EN0_RSARHI);
585 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
587 if (ei_status.word16)
588 insw(NE_BASE + NE_DATAPORT, hdr,
589 sizeof(struct e8390_pkt_hdr)>>1);
590 else
591 insb(NE_BASE + NE_DATAPORT, hdr,
592 sizeof(struct e8390_pkt_hdr));
594 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
595 ei_status.dmaing &= ~0x01;
596 }
598 /* Block input and output, similar to the Crynwr packet driver. If you
599 are porting to a new ethercard, look at the packet driver source for
600 hints. The NEx000 doesn't share the on-board packet memory -- you have
601 to put the packet out through the "remote DMA" dataport using outb. */
603 static void ne_block_input(struct net_device *dev, int count, struct sk_buff *skb,
604 int ring_offset)
605 {
606 #ifdef NE_SANITY_CHECK
607 int xfer_count = count;
608 #endif
609 int nic_base = dev->base_addr;
610 char *buf = skb->data;
612 /* This *shouldn't* happen.
613 If it does, it's the last thing you'll see */
614 if (ei_status.dmaing) {
615 printk("%s: DMAing conflict in ne_block_input "
616 "[DMAstat:%d][irqlock:%d].\n",
617 dev->name, ei_status.dmaing, ei_status.irqlock);
618 return;
619 }
620 ei_status.dmaing |= 0x01;
621 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
622 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
623 outb_p(count >> 8, nic_base + EN0_RCNTHI);
624 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
625 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
626 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
627 if (ei_status.word16) {
628 insw(NE_BASE + NE_DATAPORT,buf,count>>1);
629 if (count & 0x01) {
630 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
631 #ifdef NE_SANITY_CHECK
632 xfer_count++;
633 #endif
634 }
635 } else {
636 insb(NE_BASE + NE_DATAPORT, buf, count);
637 }
639 #ifdef NE_SANITY_CHECK
640 /* This was for the ALPHA version only, but enough people have
641 been encountering problems so it is still here. If you see
642 this message you either 1) have a slightly incompatible clone
643 or 2) have noise/speed problems with your bus. */
644 if (ei_debug > 1) { /* DMA termination address check... */
645 int addr, tries = 20;
646 do {
647 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
648 -- it's broken for Rx on some cards! */
649 int high = inb_p(nic_base + EN0_RSARHI);
650 int low = inb_p(nic_base + EN0_RSARLO);
651 addr = (high << 8) + low;
652 if (((ring_offset + xfer_count) & 0xff) == low)
653 break;
654 } while (--tries > 0);
655 if (tries <= 0)
656 printk("%s: RX transfer address mismatch,"
657 "%#4.4x (expected) vs. %#4.4x (actual).\n",
658 dev->name, ring_offset + xfer_count, addr);
659 }
660 #endif
661 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
662 ei_status.dmaing &= ~0x01;
663 }
665 static void ne_block_output(struct net_device *dev, int count,
666 const unsigned char *buf, const int start_page)
667 {
668 int nic_base = NE_BASE;
669 unsigned long dma_start;
670 #ifdef NE_SANITY_CHECK
671 int retries = 0;
672 #endif
674 /* Round the count up for word writes. Do we need to do this?
675 What effect will an odd byte count have on the 8390?
676 I should check someday. */
677 if (ei_status.word16 && (count & 0x01))
678 count++;
680 /* This *shouldn't* happen.
681 If it does, it's the last thing you'll see */
682 if (ei_status.dmaing) {
683 printk("%s: DMAing conflict in ne_block_output."
684 "[DMAstat:%d][irqlock:%d]\n",
685 dev->name, ei_status.dmaing, ei_status.irqlock);
686 return;
687 }
688 ei_status.dmaing |= 0x01;
689 /* We should already be in page 0, but to be safe... */
690 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
692 #ifdef NE_SANITY_CHECK
693 retry:
694 #endif
696 #ifdef NE8390_RW_BUGFIX
697 /* Handle the read-before-write bug the same way as the
698 Crynwr packet driver -- the NatSemi method doesn't work.
699 Actually this doesn't always work either, but if you have
700 problems with your NEx000 this is better than nothing! */
701 outb_p(0x42, nic_base + EN0_RCNTLO);
702 outb_p(0x00, nic_base + EN0_RCNTHI);
703 outb_p(0x42, nic_base + EN0_RSARLO);
704 outb_p(0x00, nic_base + EN0_RSARHI);
705 outb_p(E8390_RREAD+E8390_START, nic_base + NE_CMD);
706 /* Make certain that the dummy read has occurred. */
707 SLOW_DOWN_IO;
708 SLOW_DOWN_IO;
709 SLOW_DOWN_IO;
710 #endif
712 outb_p(ENISR_RDC, nic_base + EN0_ISR);
714 /* Now the normal output. */
715 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
716 outb_p(count >> 8, nic_base + EN0_RCNTHI);
717 outb_p(0x00, nic_base + EN0_RSARLO);
718 outb_p(start_page, nic_base + EN0_RSARHI);
720 outb_p(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
721 if (ei_status.word16) {
722 outsw(NE_BASE + NE_DATAPORT, buf, count>>1);
723 } else {
724 outsb(NE_BASE + NE_DATAPORT, buf, count);
725 }
727 dma_start = jiffies;
729 #ifdef NE_SANITY_CHECK
730 /* This was for the ALPHA version only, but enough people have
731 been encountering problems so it is still here. */
733 if (ei_debug > 1) { /* DMA termination address check... */
734 int addr, tries = 20;
735 do {
736 int high = inb_p(nic_base + EN0_RSARHI);
737 int low = inb_p(nic_base + EN0_RSARLO);
738 addr = (high << 8) + low;
739 if ((start_page << 8) + count == addr)
740 break;
741 } while (--tries > 0);
742 if (tries <= 0) {
743 printk("%s: Tx packet transfer address mismatch,"
744 "%#4.4x (expected) vs. %#4.4x (actual).\n",
745 dev->name, (start_page << 8) + count, addr);
746 if (retries++ == 0)
747 goto retry;
748 }
749 }
750 #endif
752 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
753 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
754 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
755 ne_reset_8390(dev);
756 NS8390_init(dev,1);
757 break;
758 }
760 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
761 ei_status.dmaing &= ~0x01;
762 return;
763 }
766 #ifdef MODULE
767 #define MAX_NE_CARDS 4 /* Max number of NE cards per module */
768 static struct net_device *dev_ne[MAX_NE_CARDS];
769 static int io[MAX_NE_CARDS];
770 static int irq[MAX_NE_CARDS];
771 static int bad[MAX_NE_CARDS]; /* 0xbad = bad sig or no reset ack */
772 MODULE_LICENSE("GPL");
774 module_param_array(io, int, NULL, 0);
775 module_param_array(irq, int, NULL, 0);
776 module_param_array(bad, int, NULL, 0);
777 MODULE_PARM_DESC(io, "(ignored)");
778 MODULE_PARM_DESC(irq, "(ignored)");
779 MODULE_PARM_DESC(bad, "(ignored)");
781 /* Module code fixed by David Weinehall */
783 int __init init_module(void)
784 {
785 struct net_device *dev;
786 int this_dev, found = 0;
788 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
789 dev = alloc_ei_netdev();
790 if (!dev)
791 break;
792 dev->irq = irq[this_dev];
793 dev->mem_end = bad[this_dev];
794 dev->base_addr = io[this_dev];
795 if (do_ne2_probe(dev) == 0) {
796 dev_ne[found++] = dev;
797 continue;
798 }
799 free_netdev(dev);
800 break;
801 }
802 if (found)
803 return 0;
804 printk(KERN_WARNING "ne2.c: No NE/2 card found\n");
805 return -ENXIO;
806 }
808 static void cleanup_card(struct net_device *dev)
809 {
810 mca_mark_as_unused(ei_status.priv);
811 mca_set_adapter_procfn( ei_status.priv, NULL, NULL);
812 free_irq(dev->irq, dev);
813 release_region(dev->base_addr, NE_IO_EXTENT);
814 }
816 void cleanup_module(void)
817 {
818 int this_dev;
820 for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
821 struct net_device *dev = dev_ne[this_dev];
822 if (dev) {
823 unregister_netdev(dev);
824 cleanup_card(dev);
825 free_netdev(dev);
826 }
827 }
828 }
829 #endif /* MODULE */