ia64/linux-2.6.18-xen.hg

view drivers/net/wd.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 /* wd.c: A WD80x3 ethernet driver for linux. */
2 /*
3 Written 1993-94 by Donald Becker.
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
14 Annapolis MD 21403
16 This is a driver for WD8003 and WD8013 "compatible" ethercards.
18 Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
20 Changelog:
22 Paul Gortmaker : multiple card support for module users, support
23 for non-standard memory sizes.
26 */
28 static const char version[] =
29 "wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/string.h>
35 #include <linux/init.h>
36 #include <linux/interrupt.h>
37 #include <linux/delay.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
41 #include <asm/io.h>
42 #include <asm/system.h>
44 #include "8390.h"
46 #define DRV_NAME "wd"
48 /* A zero-terminated list of I/O addresses to be probed. */
49 static unsigned int wd_portlist[] __initdata =
50 {0x300, 0x280, 0x380, 0x240, 0};
52 static int wd_probe1(struct net_device *dev, int ioaddr);
54 static int wd_open(struct net_device *dev);
55 static void wd_reset_8390(struct net_device *dev);
56 static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
57 int ring_page);
58 static void wd_block_input(struct net_device *dev, int count,
59 struct sk_buff *skb, int ring_offset);
60 static void wd_block_output(struct net_device *dev, int count,
61 const unsigned char *buf, int start_page);
62 static int wd_close(struct net_device *dev);
65 #define WD_START_PG 0x00 /* First page of TX buffer */
66 #define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */
67 #define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */
69 #define WD_CMDREG 0 /* Offset to ASIC command register. */
70 #define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */
71 #define WD_MEMENB 0x40 /* Enable the shared memory. */
72 #define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */
73 #define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */
74 #define NIC16 0x40 /* Enable 16 bit access from the 8390. */
75 #define WD_NIC_OFFSET 16 /* Offset to the 8390 from the base_addr. */
76 #define WD_IO_EXTENT 32
79 /* Probe for the WD8003 and WD8013. These cards have the station
80 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
81 following. A Soundblaster can have the same checksum as an WDethercard,
82 so we have an extra exclusionary check for it.
84 The wd_probe1() routine initializes the card and fills the
85 station address field. */
87 static int __init do_wd_probe(struct net_device *dev)
88 {
89 int i;
90 struct resource *r;
91 int base_addr = dev->base_addr;
92 int irq = dev->irq;
93 int mem_start = dev->mem_start;
94 int mem_end = dev->mem_end;
96 SET_MODULE_OWNER(dev);
98 if (base_addr > 0x1ff) { /* Check a user specified location. */
99 r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
100 if ( r == NULL)
101 return -EBUSY;
102 i = wd_probe1(dev, base_addr);
103 if (i != 0)
104 release_region(base_addr, WD_IO_EXTENT);
105 else
106 r->name = dev->name;
107 return i;
108 }
109 else if (base_addr != 0) /* Don't probe at all. */
110 return -ENXIO;
112 for (i = 0; wd_portlist[i]; i++) {
113 int ioaddr = wd_portlist[i];
114 r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
115 if (r == NULL)
116 continue;
117 if (wd_probe1(dev, ioaddr) == 0) {
118 r->name = dev->name;
119 return 0;
120 }
121 release_region(ioaddr, WD_IO_EXTENT);
122 dev->irq = irq;
123 dev->mem_start = mem_start;
124 dev->mem_end = mem_end;
125 }
127 return -ENODEV;
128 }
130 #ifndef MODULE
131 struct net_device * __init wd_probe(int unit)
132 {
133 struct net_device *dev = alloc_ei_netdev();
134 int err;
136 if (!dev)
137 return ERR_PTR(-ENOMEM);
139 sprintf(dev->name, "eth%d", unit);
140 netdev_boot_setup_check(dev);
142 err = do_wd_probe(dev);
143 if (err)
144 goto out;
145 return dev;
146 out:
147 free_netdev(dev);
148 return ERR_PTR(err);
149 }
150 #endif
152 static int __init wd_probe1(struct net_device *dev, int ioaddr)
153 {
154 int i;
155 int err;
156 int checksum = 0;
157 int ancient = 0; /* An old card without config registers. */
158 int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
159 const char *model_name;
160 static unsigned version_printed;
162 for (i = 0; i < 8; i++)
163 checksum += inb(ioaddr + 8 + i);
164 if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
165 || inb(ioaddr + 9) == 0xff
166 || (checksum & 0xff) != 0xFF)
167 return -ENODEV;
169 /* Check for semi-valid mem_start/end values if supplied. */
170 if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
171 printk(KERN_WARNING "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
172 dev->mem_start = 0;
173 dev->mem_end = 0;
174 }
176 if (ei_debug && version_printed++ == 0)
177 printk(version);
179 printk("%s: WD80x3 at %#3x,", dev->name, ioaddr);
180 for (i = 0; i < 6; i++)
181 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
183 /* The following PureData probe code was contributed by
184 Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
185 configuration differently from others so we have to check for them.
186 This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
187 */
188 if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
189 unsigned char reg5 = inb(ioaddr+5);
191 switch (inb(ioaddr+2)) {
192 case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
193 case 0x05: word16 = 0; model_name = "PDUC8023"; break;
194 case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
195 /* Either 0x01 (dumb) or they've released a new version. */
196 default: word16 = 0; model_name = "PDI8023"; break;
197 }
198 dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
199 dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
200 } else { /* End of PureData probe */
201 /* This method of checking for a 16-bit board is borrowed from the
202 we.c driver. A simpler method is just to look in ASIC reg. 0x03.
203 I'm comparing the two method in alpha test to make certain they
204 return the same result. */
205 /* Check for the old 8 bit board - it has register 0/8 aliasing.
206 Do NOT check i>=6 here -- it hangs the old 8003 boards! */
207 for (i = 0; i < 6; i++)
208 if (inb(ioaddr+i) != inb(ioaddr+8+i))
209 break;
210 if (i >= 6) {
211 ancient = 1;
212 model_name = "WD8003-old";
213 word16 = 0;
214 } else {
215 int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
216 outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
217 if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
218 && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
219 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
220 /* Magic to set ASIC to word-wide mode. */
221 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
222 outb(tmp, ioaddr+1);
223 model_name = "WD8013";
224 word16 = 1; /* We have a 16bit board here! */
225 } else {
226 model_name = "WD8003";
227 word16 = 0;
228 }
229 outb(tmp, ioaddr+1); /* Restore original reg1 value. */
230 }
231 #ifndef final_version
232 if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
233 printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
234 word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8);
235 #endif
236 }
238 #if defined(WD_SHMEM) && WD_SHMEM > 0x80000
239 /* Allow a compile-time override. */
240 dev->mem_start = WD_SHMEM;
241 #else
242 if (dev->mem_start == 0) {
243 /* Sanity and old 8003 check */
244 int reg0 = inb(ioaddr);
245 if (reg0 == 0xff || reg0 == 0) {
246 /* Future plan: this could check a few likely locations first. */
247 dev->mem_start = 0xd0000;
248 printk(" assigning address %#lx", dev->mem_start);
249 } else {
250 int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
251 /* Some boards don't have the register 5 -- it returns 0xff. */
252 if (high_addr_bits == 0x1f || word16 == 0)
253 high_addr_bits = 0x01;
254 dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
255 }
256 }
257 #endif
259 /* The 8390 isn't at the base address -- the ASIC regs are there! */
260 dev->base_addr = ioaddr+WD_NIC_OFFSET;
262 if (dev->irq < 2) {
263 int irqmap[] = {9,3,5,7,10,11,15,4};
264 int reg1 = inb(ioaddr+1);
265 int reg4 = inb(ioaddr+4);
266 if (ancient || reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
267 short nic_addr = ioaddr+WD_NIC_OFFSET;
268 unsigned long irq_mask;
270 /* We have an old-style ethercard that doesn't report its IRQ
271 line. Do autoirq to find the IRQ line. Note that this IS NOT
272 a reliable way to trigger an interrupt. */
273 outb_p(E8390_NODMA + E8390_STOP, nic_addr);
274 outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
276 irq_mask = probe_irq_on();
277 outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
278 outb_p(0x00, nic_addr + EN0_RCNTLO);
279 outb_p(0x00, nic_addr + EN0_RCNTHI);
280 outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
281 mdelay(20);
282 dev->irq = probe_irq_off(irq_mask);
284 outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
286 if (ei_debug > 2)
287 printk(" autoirq is %d", dev->irq);
288 if (dev->irq < 2)
289 dev->irq = word16 ? 10 : 5;
290 } else
291 dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
292 } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
293 dev->irq = 9;
295 /* Snarf the interrupt now. There's no point in waiting since we cannot
296 share and the board will usually be enabled. */
297 i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
298 if (i) {
299 printk (" unable to get IRQ %d.\n", dev->irq);
300 return i;
301 }
303 /* OK, were are certain this is going to work. Setup the device. */
304 ei_status.name = model_name;
305 ei_status.word16 = word16;
306 ei_status.tx_start_page = WD_START_PG;
307 ei_status.rx_start_page = WD_START_PG + TX_PAGES;
309 /* Don't map in the shared memory until the board is actually opened. */
311 /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
312 if (dev->mem_end != 0) {
313 ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
314 ei_status.priv = dev->mem_end - dev->mem_start;
315 } else {
316 ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
317 dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
318 ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
319 }
321 ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
322 if (!ei_status.mem) {
323 free_irq(dev->irq, dev);
324 return -ENOMEM;
325 }
327 printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
328 model_name, dev->irq, dev->mem_start, dev->mem_end-1);
330 ei_status.reset_8390 = &wd_reset_8390;
331 ei_status.block_input = &wd_block_input;
332 ei_status.block_output = &wd_block_output;
333 ei_status.get_8390_hdr = &wd_get_8390_hdr;
334 dev->open = &wd_open;
335 dev->stop = &wd_close;
336 #ifdef CONFIG_NET_POLL_CONTROLLER
337 dev->poll_controller = ei_poll;
338 #endif
339 NS8390_init(dev, 0);
341 #if 1
342 /* Enable interrupt generation on softconfig cards -- M.U */
343 /* .. but possibly potentially unsafe - Donald */
344 if (inb(ioaddr+14) & 0x20)
345 outb(inb(ioaddr+4)|0x80, ioaddr+4);
346 #endif
348 err = register_netdev(dev);
349 if (err)
350 free_irq(dev->irq, dev);
351 return err;
352 }
354 static int
355 wd_open(struct net_device *dev)
356 {
357 int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
359 /* Map in the shared memory. Always set register 0 last to remain
360 compatible with very old boards. */
361 ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
362 ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
364 if (ei_status.word16)
365 outb(ei_status.reg5, ioaddr+WD_CMDREG5);
366 outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
368 ei_open(dev);
369 return 0;
370 }
372 static void
373 wd_reset_8390(struct net_device *dev)
374 {
375 int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
377 outb(WD_RESET, wd_cmd_port);
378 if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies);
379 ei_status.txing = 0;
381 /* Set up the ASIC registers, just in case something changed them. */
382 outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
383 if (ei_status.word16)
384 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
386 if (ei_debug > 1) printk("reset done\n");
387 return;
388 }
390 /* Grab the 8390 specific header. Similar to the block_input routine, but
391 we don't need to be concerned with ring wrap as the header will be at
392 the start of a page, so we optimize accordingly. */
394 static void
395 wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
396 {
398 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
399 void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
401 /* We'll always get a 4 byte header read followed by a packet read, so
402 we enable 16 bit mode before the header, and disable after the body. */
403 if (ei_status.word16)
404 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
406 #ifdef __BIG_ENDIAN
407 /* Officially this is what we are doing, but the readl() is faster */
408 /* unfortunately it isn't endian aware of the struct */
409 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
410 hdr->count = le16_to_cpu(hdr->count);
411 #else
412 ((unsigned int*)hdr)[0] = readl(hdr_start);
413 #endif
414 }
416 /* Block input and output are easy on shared memory ethercards, and trivial
417 on the Western digital card where there is no choice of how to do it.
418 The only complications are that the ring buffer wraps, and need to map
419 switch between 8- and 16-bit modes. */
421 static void
422 wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
423 {
424 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
425 unsigned long offset = ring_offset - (WD_START_PG<<8);
426 void __iomem *xfer_start = ei_status.mem + offset;
428 if (offset + count > ei_status.priv) {
429 /* We must wrap the input move. */
430 int semi_count = ei_status.priv - offset;
431 memcpy_fromio(skb->data, xfer_start, semi_count);
432 count -= semi_count;
433 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
434 } else {
435 /* Packet is in one chunk -- we can copy + cksum. */
436 eth_io_copy_and_sum(skb, xfer_start, count, 0);
437 }
439 /* Turn off 16 bit access so that reboot works. ISA brain-damage */
440 if (ei_status.word16)
441 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
442 }
444 static void
445 wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
446 int start_page)
447 {
448 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
449 void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
452 if (ei_status.word16) {
453 /* Turn on and off 16 bit access so that reboot works. */
454 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
455 memcpy_toio(shmem, buf, count);
456 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
457 } else
458 memcpy_toio(shmem, buf, count);
459 }
462 static int
463 wd_close(struct net_device *dev)
464 {
465 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
467 if (ei_debug > 1)
468 printk("%s: Shutting down ethercard.\n", dev->name);
469 ei_close(dev);
471 /* Change from 16-bit to 8-bit shared memory so reboot works. */
472 if (ei_status.word16)
473 outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
475 /* And disable the shared memory. */
476 outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
478 return 0;
479 }
482 #ifdef MODULE
483 #define MAX_WD_CARDS 4 /* Max number of wd cards per module */
484 static struct net_device *dev_wd[MAX_WD_CARDS];
485 static int io[MAX_WD_CARDS];
486 static int irq[MAX_WD_CARDS];
487 static int mem[MAX_WD_CARDS];
488 static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */
490 module_param_array(io, int, NULL, 0);
491 module_param_array(irq, int, NULL, 0);
492 module_param_array(mem, int, NULL, 0);
493 module_param_array(mem_end, int, NULL, 0);
494 MODULE_PARM_DESC(io, "I/O base address(es)");
495 MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
496 MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
497 MODULE_PARM_DESC(mem_end, "memory end address(es)");
498 MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
499 MODULE_LICENSE("GPL");
501 /* This is set up so that only a single autoprobe takes place per call.
502 ISA device autoprobes on a running machine are not recommended. */
504 int __init init_module(void)
505 {
506 struct net_device *dev;
507 int this_dev, found = 0;
509 for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
510 if (io[this_dev] == 0) {
511 if (this_dev != 0) break; /* only autoprobe 1st one */
512 printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
513 }
514 dev = alloc_ei_netdev();
515 if (!dev)
516 break;
517 dev->irq = irq[this_dev];
518 dev->base_addr = io[this_dev];
519 dev->mem_start = mem[this_dev];
520 dev->mem_end = mem_end[this_dev];
521 if (do_wd_probe(dev) == 0) {
522 dev_wd[found++] = dev;
523 continue;
524 }
525 free_netdev(dev);
526 printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
527 break;
528 }
529 if (found)
530 return 0;
531 return -ENXIO;
532 }
534 static void cleanup_card(struct net_device *dev)
535 {
536 free_irq(dev->irq, dev);
537 release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
538 iounmap(ei_status.mem);
539 }
541 void
542 cleanup_module(void)
543 {
544 int this_dev;
546 for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
547 struct net_device *dev = dev_wd[this_dev];
548 if (dev) {
549 unregister_netdev(dev);
550 cleanup_card(dev);
551 free_netdev(dev);
552 }
553 }
554 }
555 #endif /* MODULE */