ia64/linux-2.6.18-xen.hg

view drivers/net/smc-ultra32.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 /* smc-ultra32.c: An SMC Ultra32 EISA ethernet driver for linux.
3 Sources:
5 This driver is based on (cloned from) the ISA SMC Ultra driver
6 written by Donald Becker. Modifications to support the EISA
7 version of the card by Paul Gortmaker and Leonard N. Zubkoff.
9 This software may be used and distributed according to the terms
10 of the GNU General Public License, incorporated herein by reference.
12 Theory of Operation:
14 The SMC Ultra32C card uses the SMC 83c790 chip which is also
15 found on the ISA SMC Ultra cards. It has a shared memory mode of
16 operation that makes it similar to the ISA version of the card.
17 The main difference is that the EISA card has 32KB of RAM, but
18 only an 8KB window into that memory. The EISA card also can be
19 set for a bus-mastering mode of operation via the ECU, but that
20 is not (and probably will never be) supported by this driver.
21 The ECU should be run to enable shared memory and to disable the
22 bus-mastering feature for use with linux.
24 By programming the 8390 to use only 8KB RAM, the modifications
25 to the ISA driver can be limited to the probe and initialization
26 code. This allows easy integration of EISA support into the ISA
27 driver. However, the driver development kit from SMC provided the
28 register information for sliding the 8KB window, and hence the 8390
29 is programmed to use the full 32KB RAM.
31 Unfortunately this required code changes outside the probe/init
32 routines, and thus we decided to separate the EISA driver from
33 the ISA one. In this way, ISA users don't end up with a larger
34 driver due to the EISA code, and EISA users don't end up with a
35 larger driver due to the ISA EtherEZ PIO code. The driver is
36 similar to the 3c503/16 driver, in that the window must be set
37 back to the 1st 8KB of space for access to the two 8390 Tx slots.
39 In testing, using only 8KB RAM (3 Tx / 5 Rx) didn't appear to
40 be a limiting factor, since the EISA bus could get packets off
41 the card fast enough, but having the use of lots of RAM as Rx
42 space is extra insurance if interrupt latencies become excessive.
44 */
46 static const char *version = "smc-ultra32.c: 06/97 v1.00\n";
49 #include <linux/module.h>
50 #include <linux/eisa.h>
51 #include <linux/kernel.h>
52 #include <linux/errno.h>
53 #include <linux/string.h>
54 #include <linux/init.h>
55 #include <linux/interrupt.h>
56 #include <linux/netdevice.h>
57 #include <linux/etherdevice.h>
59 #include <asm/io.h>
60 #include <asm/system.h>
62 #include "8390.h"
64 #define DRV_NAME "smc-ultra32"
66 static int ultra32_probe1(struct net_device *dev, int ioaddr);
67 static int ultra32_open(struct net_device *dev);
68 static void ultra32_reset_8390(struct net_device *dev);
69 static void ultra32_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
70 int ring_page);
71 static void ultra32_block_input(struct net_device *dev, int count,
72 struct sk_buff *skb, int ring_offset);
73 static void ultra32_block_output(struct net_device *dev, int count,
74 const unsigned char *buf,
75 const int start_page);
76 static int ultra32_close(struct net_device *dev);
78 #define ULTRA32_CMDREG 0 /* Offset to ASIC command register. */
79 #define ULTRA32_RESET 0x80 /* Board reset, in ULTRA32_CMDREG. */
80 #define ULTRA32_MEMENB 0x40 /* Enable the shared memory. */
81 #define ULTRA32_NIC_OFFSET 16 /* NIC register offset from the base_addr. */
82 #define ULTRA32_IO_EXTENT 32
83 #define EN0_ERWCNT 0x08 /* Early receive warning count. */
85 /*
86 * Defines that apply only to the Ultra32 EISA card. Note that
87 * "smc" = 10011 01101 00011 = 0x4da3, and hence !smc8010.cfg translates
88 * into an EISA ID of 0x1080A34D
89 */
90 #define ULTRA32_BASE 0xca0
91 #define ULTRA32_ID 0x1080a34d
92 #define ULTRA32_IDPORT (-0x20) /* 0xc80 */
93 /* Config regs 1->7 from the EISA !SMC8010.CFG file. */
94 #define ULTRA32_CFG1 0x04 /* 0xca4 */
95 #define ULTRA32_CFG2 0x05 /* 0xca5 */
96 #define ULTRA32_CFG3 (-0x18) /* 0xc88 */
97 #define ULTRA32_CFG4 (-0x17) /* 0xc89 */
98 #define ULTRA32_CFG5 (-0x16) /* 0xc8a */
99 #define ULTRA32_CFG6 (-0x15) /* 0xc8b */
100 #define ULTRA32_CFG7 0x0d /* 0xcad */
102 static void cleanup_card(struct net_device *dev)
103 {
104 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET;
105 /* NB: ultra32_close_card() does free_irq */
106 release_region(ioaddr, ULTRA32_IO_EXTENT);
107 iounmap(ei_status.mem);
108 }
110 /* Probe for the Ultra32. This looks like a 8013 with the station
111 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
112 following.
113 */
115 struct net_device * __init ultra32_probe(int unit)
116 {
117 struct net_device *dev;
118 int base;
119 int irq;
120 int err = -ENODEV;
122 if (!EISA_bus)
123 return ERR_PTR(-ENODEV);
125 dev = alloc_ei_netdev();
127 if (!dev)
128 return ERR_PTR(-ENOMEM);
130 if (unit >= 0) {
131 sprintf(dev->name, "eth%d", unit);
132 netdev_boot_setup_check(dev);
133 }
135 SET_MODULE_OWNER(dev);
137 irq = dev->irq;
139 /* EISA spec allows for up to 16 slots, but 8 is typical. */
140 for (base = 0x1000 + ULTRA32_BASE; base < 0x9000; base += 0x1000) {
141 if (ultra32_probe1(dev, base) == 0)
142 break;
143 dev->irq = irq;
144 }
145 if (base >= 0x9000)
146 goto out;
147 err = register_netdev(dev);
148 if (err)
149 goto out1;
150 return dev;
151 out1:
152 cleanup_card(dev);
153 out:
154 free_netdev(dev);
155 return ERR_PTR(err);
156 }
158 static int __init ultra32_probe1(struct net_device *dev, int ioaddr)
159 {
160 int i, edge, media, retval;
161 int checksum = 0;
162 const char *model_name;
163 static unsigned version_printed;
164 /* Values from various config regs. */
165 unsigned char idreg;
166 unsigned char reg4;
167 const char *ifmap[] = {"UTP No Link", "", "UTP/AUI", "UTP/BNC"};
169 if (!request_region(ioaddr, ULTRA32_IO_EXTENT, DRV_NAME))
170 return -EBUSY;
172 if (inb(ioaddr + ULTRA32_IDPORT) == 0xff ||
173 inl(ioaddr + ULTRA32_IDPORT) != ULTRA32_ID) {
174 retval = -ENODEV;
175 goto out;
176 }
178 media = inb(ioaddr + ULTRA32_CFG7) & 0x03;
179 edge = inb(ioaddr + ULTRA32_CFG5) & 0x08;
180 printk("SMC Ultra32 in EISA Slot %d, Media: %s, %s IRQs.\n",
181 ioaddr >> 12, ifmap[media],
182 (edge ? "Edge Triggered" : "Level Sensitive"));
184 idreg = inb(ioaddr + 7);
185 reg4 = inb(ioaddr + 4) & 0x7f;
187 /* Check the ID nibble. */
188 if ((idreg & 0xf0) != 0x20) { /* SMC Ultra */
189 retval = -ENODEV;
190 goto out;
191 }
193 /* Select the station address register set. */
194 outb(reg4, ioaddr + 4);
196 for (i = 0; i < 8; i++)
197 checksum += inb(ioaddr + 8 + i);
198 if ((checksum & 0xff) != 0xff) {
199 retval = -ENODEV;
200 goto out;
201 }
203 if (ei_debug && version_printed++ == 0)
204 printk(version);
206 model_name = "SMC Ultra32";
208 printk("%s: %s at 0x%X,", dev->name, model_name, ioaddr);
210 for (i = 0; i < 6; i++)
211 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
213 /* Switch from the station address to the alternate register set and
214 read the useful registers there. */
215 outb(0x80 | reg4, ioaddr + 4);
217 /* Enable FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
218 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
220 /* Reset RAM addr. */
221 outb(0x00, ioaddr + 0x0b);
223 /* Switch back to the station address register set so that the
224 MS-DOS driver can find the card after a warm boot. */
225 outb(reg4, ioaddr + 4);
227 if ((inb(ioaddr + ULTRA32_CFG5) & 0x40) == 0) {
228 printk("\nsmc-ultra32: Card RAM is disabled! "
229 "Run EISA config utility.\n");
230 retval = -ENODEV;
231 goto out;
232 }
233 if ((inb(ioaddr + ULTRA32_CFG2) & 0x04) == 0)
234 printk("\nsmc-ultra32: Ignoring Bus-Master enable bit. "
235 "Run EISA config utility.\n");
237 if (dev->irq < 2) {
238 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
239 int irq = irqmap[inb(ioaddr + ULTRA32_CFG5) & 0x07];
240 if (irq == 0) {
241 printk(", failed to detect IRQ line.\n");
242 retval = -EAGAIN;
243 goto out;
244 }
245 dev->irq = irq;
246 }
248 /* The 8390 isn't at the base address, so fake the offset */
249 dev->base_addr = ioaddr + ULTRA32_NIC_OFFSET;
251 /* Save RAM address in the unused reg0 to avoid excess inb's. */
252 ei_status.reg0 = inb(ioaddr + ULTRA32_CFG3) & 0xfc;
254 dev->mem_start = 0xc0000 + ((ei_status.reg0 & 0x7c) << 11);
256 ei_status.name = model_name;
257 ei_status.word16 = 1;
258 ei_status.tx_start_page = 0;
259 ei_status.rx_start_page = TX_PAGES;
260 /* All Ultra32 cards have 32KB memory with an 8KB window. */
261 ei_status.stop_page = 128;
263 ei_status.mem = ioremap(dev->mem_start, 0x2000);
264 if (!ei_status.mem) {
265 printk(", failed to ioremap.\n");
266 retval = -ENOMEM;
267 goto out;
268 }
269 dev->mem_end = dev->mem_start + 0x1fff;
271 printk(", IRQ %d, 32KB memory, 8KB window at 0x%lx-0x%lx.\n",
272 dev->irq, dev->mem_start, dev->mem_end);
273 ei_status.block_input = &ultra32_block_input;
274 ei_status.block_output = &ultra32_block_output;
275 ei_status.get_8390_hdr = &ultra32_get_8390_hdr;
276 ei_status.reset_8390 = &ultra32_reset_8390;
277 dev->open = &ultra32_open;
278 dev->stop = &ultra32_close;
279 #ifdef CONFIG_NET_POLL_CONTROLLER
280 dev->poll_controller = ei_poll;
281 #endif
282 NS8390_init(dev, 0);
284 return 0;
285 out:
286 release_region(ioaddr, ULTRA32_IO_EXTENT);
287 return retval;
288 }
290 static int ultra32_open(struct net_device *dev)
291 {
292 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC addr */
293 int irq_flags = (inb(ioaddr + ULTRA32_CFG5) & 0x08) ? 0 : IRQF_SHARED;
294 int retval;
296 retval = request_irq(dev->irq, ei_interrupt, irq_flags, dev->name, dev);
297 if (retval)
298 return retval;
300 outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
301 outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
302 outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
303 outb(0x01, ioaddr + 6); /* Enable Interrupts. */
304 /* Set the early receive warning level in window 0 high enough not
305 to receive ERW interrupts. */
306 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
307 outb(0xff, dev->base_addr + EN0_ERWCNT);
308 ei_open(dev);
309 return 0;
310 }
312 static int ultra32_close(struct net_device *dev)
313 {
314 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* CMDREG */
316 netif_stop_queue(dev);
318 if (ei_debug > 1)
319 printk("%s: Shutting down ethercard.\n", dev->name);
321 outb(0x00, ioaddr + ULTRA32_CFG6); /* Disable Interrupts. */
322 outb(0x00, ioaddr + 6); /* Disable interrupts. */
323 free_irq(dev->irq, dev);
325 NS8390_init(dev, 0);
327 return 0;
328 }
330 static void ultra32_reset_8390(struct net_device *dev)
331 {
332 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC base addr */
334 outb(ULTRA32_RESET, ioaddr);
335 if (ei_debug > 1) printk("resetting Ultra32, t=%ld...", jiffies);
336 ei_status.txing = 0;
338 outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
339 outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
340 outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
341 outb(0x01, ioaddr + 6); /* Enable Interrupts. */
342 if (ei_debug > 1) printk("reset done\n");
343 return;
344 }
346 /* Grab the 8390 specific header. Similar to the block_input routine, but
347 we don't need to be concerned with ring wrap as the header will be at
348 the start of a page, so we optimize accordingly. */
350 static void ultra32_get_8390_hdr(struct net_device *dev,
351 struct e8390_pkt_hdr *hdr,
352 int ring_page)
353 {
354 void __iomem *hdr_start = ei_status.mem + ((ring_page & 0x1f) << 8);
355 unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
357 /* Select correct 8KB Window. */
358 outb(ei_status.reg0 | ((ring_page & 0x60) >> 5), RamReg);
360 #ifdef __BIG_ENDIAN
361 /* Officially this is what we are doing, but the readl() is faster */
362 /* unfortunately it isn't endian aware of the struct */
363 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
364 hdr->count = le16_to_cpu(hdr->count);
365 #else
366 ((unsigned int*)hdr)[0] = readl(hdr_start);
367 #endif
368 }
370 /* Block input and output are easy on shared memory ethercards, the only
371 complication is when the ring buffer wraps, or in this case, when a
372 packet spans an 8KB boundary. Note that the current 8KB segment is
373 already set by the get_8390_hdr routine. */
375 static void ultra32_block_input(struct net_device *dev,
376 int count,
377 struct sk_buff *skb,
378 int ring_offset)
379 {
380 void __iomem *xfer_start = ei_status.mem + (ring_offset & 0x1fff);
381 unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
383 if ((ring_offset & ~0x1fff) != ((ring_offset + count - 1) & ~0x1fff)) {
384 int semi_count = 8192 - (ring_offset & 0x1FFF);
385 memcpy_fromio(skb->data, xfer_start, semi_count);
386 count -= semi_count;
387 if (ring_offset < 96*256) {
388 /* Select next 8KB Window. */
389 ring_offset += semi_count;
390 outb(ei_status.reg0 | ((ring_offset & 0x6000) >> 13), RamReg);
391 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
392 } else {
393 /* Select first 8KB Window. */
394 outb(ei_status.reg0, RamReg);
395 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
396 }
397 } else {
398 /* Packet is in one chunk -- we can copy + cksum. */
399 eth_io_copy_and_sum(skb, xfer_start, count, 0);
400 }
401 }
403 static void ultra32_block_output(struct net_device *dev,
404 int count,
405 const unsigned char *buf,
406 int start_page)
407 {
408 void __iomem *xfer_start = ei_status.mem + (start_page<<8);
409 unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
411 /* Select first 8KB Window. */
412 outb(ei_status.reg0, RamReg);
414 memcpy_toio(xfer_start, buf, count);
415 }
417 #ifdef MODULE
418 #define MAX_ULTRA32_CARDS 4 /* Max number of Ultra cards per module */
419 static struct net_device *dev_ultra[MAX_ULTRA32_CARDS];
421 MODULE_DESCRIPTION("SMC Ultra32 EISA ethernet driver");
422 MODULE_LICENSE("GPL");
424 int __init init_module(void)
425 {
426 int this_dev, found = 0;
428 for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
429 struct net_device *dev = ultra32_probe(-1);
430 if (IS_ERR(dev))
431 break;
432 dev_ultra[found++] = dev;
433 }
434 if (found)
435 return 0;
436 printk(KERN_WARNING "smc-ultra32.c: No SMC Ultra32 found.\n");
437 return -ENXIO;
438 }
440 void cleanup_module(void)
441 {
442 int this_dev;
444 for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
445 struct net_device *dev = dev_ultra[this_dev];
446 if (dev) {
447 unregister_netdev(dev);
448 cleanup_card(dev);
449 free_netdev(dev);
450 }
451 }
452 }
453 #endif /* MODULE */