ia64/linux-2.6.18-xen.hg

view drivers/net/ne3210.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 /*
2 ne3210.c
4 Linux driver for Novell NE3210 EISA Network Adapter
6 Copyright (C) 1998, Paul Gortmaker.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 Information and Code Sources:
13 1) Based upon my other EISA 8390 drivers (lne390, es3210, smc-ultra32)
14 2) The existing myriad of other Linux 8390 drivers by Donald Becker.
15 3) Info for getting IRQ and sh-mem gleaned from the EISA cfg file
17 The NE3210 is an EISA shared memory NS8390 implementation. Shared
18 memory address > 1MB should work with this driver.
20 Note that the .cfg file (3/11/93, v1.0) has AUI and BNC switched
21 around (or perhaps there are some defective/backwards cards ???)
23 This driver WILL NOT WORK FOR THE NE3200 - it is completely different
24 and does not use an 8390 at all.
26 Updated to EISA probing API 5/2003 by Marc Zyngier.
27 */
29 #include <linux/module.h>
30 #include <linux/eisa.h>
31 #include <linux/kernel.h>
32 #include <linux/errno.h>
33 #include <linux/string.h>
34 #include <linux/delay.h>
35 #include <linux/init.h>
36 #include <linux/interrupt.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
40 #include <asm/io.h>
41 #include <asm/system.h>
43 #include "8390.h"
45 #define DRV_NAME "ne3210"
47 static int ne3210_open(struct net_device *dev);
48 static int ne3210_close(struct net_device *dev);
50 static void ne3210_reset_8390(struct net_device *dev);
52 static void ne3210_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
53 static void ne3210_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
54 static void ne3210_block_output(struct net_device *dev, int count, const unsigned char *buf, const int start_page);
56 #define NE3210_START_PG 0x00 /* First page of TX buffer */
57 #define NE3210_STOP_PG 0x80 /* Last page +1 of RX ring */
59 #define NE3210_IO_EXTENT 0x20
60 #define NE3210_SA_PROM 0x16 /* Start of e'net addr. */
61 #define NE3210_RESET_PORT 0xc84
62 #define NE3210_NIC_OFFSET 0x00 /* Hello, the 8390 is *here* */
64 #define NE3210_ADDR0 0x00 /* 3 byte vendor prefix */
65 #define NE3210_ADDR1 0x00
66 #define NE3210_ADDR2 0x1b
68 #define NE3210_CFG1 0xc84 /* NB: 0xc84 is also "reset" port. */
69 #define NE3210_CFG2 0xc90
70 #define NE3210_CFG_EXTENT (NE3210_CFG2 - NE3210_CFG1 + 1)
72 /*
73 * You can OR any of the following bits together and assign it
74 * to NE3210_DEBUG to get verbose driver info during operation.
75 * Currently only the probe one is implemented.
76 */
78 #define NE3210_D_PROBE 0x01
79 #define NE3210_D_RX_PKT 0x02
80 #define NE3210_D_TX_PKT 0x04
81 #define NE3210_D_IRQ 0x08
83 #define NE3210_DEBUG 0x0
85 static unsigned char irq_map[] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
86 static unsigned int shmem_map[] __initdata = {0xff0, 0xfe0, 0xfff0, 0xd8, 0xffe0, 0xffc0, 0xd0, 0x0};
87 static const char *ifmap[] __initdata = {"UTP", "?", "BNC", "AUI"};
88 static int ifmap_val[] __initdata = {
89 IF_PORT_10BASET,
90 IF_PORT_UNKNOWN,
91 IF_PORT_10BASE2,
92 IF_PORT_AUI,
93 };
95 static int __init ne3210_eisa_probe (struct device *device)
96 {
97 unsigned long ioaddr, phys_mem;
98 int i, retval, port_index;
99 struct eisa_device *edev = to_eisa_device (device);
100 struct net_device *dev;
102 /* Allocate dev->priv and fill in 8390 specific dev fields. */
103 if (!(dev = alloc_ei_netdev ())) {
104 printk ("ne3210.c: unable to allocate memory for dev!\n");
105 return -ENOMEM;
106 }
108 SET_MODULE_OWNER(dev);
109 SET_NETDEV_DEV(dev, device);
110 device->driver_data = dev;
111 ioaddr = edev->base_addr;
113 if (!request_region(ioaddr, NE3210_IO_EXTENT, DRV_NAME)) {
114 retval = -EBUSY;
115 goto out;
116 }
118 if (!request_region(ioaddr + NE3210_CFG1,
119 NE3210_CFG_EXTENT, DRV_NAME)) {
120 retval = -EBUSY;
121 goto out1;
122 }
124 #if NE3210_DEBUG & NE3210_D_PROBE
125 printk("ne3210-debug: probe at %#x, ID %s\n", ioaddr, edev->id.sig);
126 printk("ne3210-debug: config regs: %#x %#x\n",
127 inb(ioaddr + NE3210_CFG1), inb(ioaddr + NE3210_CFG2));
128 #endif
131 port_index = inb(ioaddr + NE3210_CFG2) >> 6;
132 printk("ne3210.c: NE3210 in EISA slot %d, media: %s, addr:",
133 edev->slot, ifmap[port_index]);
134 for(i = 0; i < ETHER_ADDR_LEN; i++)
135 printk(" %02x", (dev->dev_addr[i] = inb(ioaddr + NE3210_SA_PROM + i)));
138 /* Snarf the interrupt now. CFG file has them all listed as `edge' with share=NO */
139 dev->irq = irq_map[(inb(ioaddr + NE3210_CFG2) >> 3) & 0x07];
140 printk(".\nne3210.c: using IRQ %d, ", dev->irq);
142 retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
143 if (retval) {
144 printk (" unable to get IRQ %d.\n", dev->irq);
145 goto out2;
146 }
148 phys_mem = shmem_map[inb(ioaddr + NE3210_CFG2) & 0x07] * 0x1000;
150 /*
151 BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
152 the card mem within the region covered by `normal' RAM !!!
153 */
154 if (phys_mem > 1024*1024) { /* phys addr > 1MB */
155 if (phys_mem < virt_to_phys(high_memory)) {
156 printk(KERN_CRIT "ne3210.c: Card RAM overlaps with normal memory!!!\n");
157 printk(KERN_CRIT "ne3210.c: Use EISA SCU to set card memory below 1MB,\n");
158 printk(KERN_CRIT "ne3210.c: or to an address above 0x%lx.\n", virt_to_phys(high_memory));
159 printk(KERN_CRIT "ne3210.c: Driver NOT installed.\n");
160 retval = -EINVAL;
161 goto out3;
162 }
163 }
165 if (!request_mem_region (phys_mem, NE3210_STOP_PG*0x100, DRV_NAME)) {
166 printk ("ne3210.c: Unable to request shared memory at physical address %#lx\n",
167 phys_mem);
168 goto out3;
169 }
171 printk("%dkB memory at physical address %#lx\n",
172 NE3210_STOP_PG/4, phys_mem);
174 ei_status.mem = ioremap(phys_mem, NE3210_STOP_PG*0x100);
175 if (!ei_status.mem) {
176 printk(KERN_ERR "ne3210.c: Unable to remap card memory !!\n");
177 printk(KERN_ERR "ne3210.c: Driver NOT installed.\n");
178 retval = -EAGAIN;
179 goto out4;
180 }
181 printk("ne3210.c: remapped %dkB card memory to virtual address %p\n",
182 NE3210_STOP_PG/4, ei_status.mem);
183 dev->mem_start = (unsigned long)ei_status.mem;
184 dev->mem_end = dev->mem_start + (NE3210_STOP_PG - NE3210_START_PG)*256;
186 /* The 8390 offset is zero for the NE3210 */
187 dev->base_addr = ioaddr;
189 ei_status.name = "NE3210";
190 ei_status.tx_start_page = NE3210_START_PG;
191 ei_status.rx_start_page = NE3210_START_PG + TX_PAGES;
192 ei_status.stop_page = NE3210_STOP_PG;
193 ei_status.word16 = 1;
194 ei_status.priv = phys_mem;
196 if (ei_debug > 0)
197 printk("ne3210 loaded.\n");
199 ei_status.reset_8390 = &ne3210_reset_8390;
200 ei_status.block_input = &ne3210_block_input;
201 ei_status.block_output = &ne3210_block_output;
202 ei_status.get_8390_hdr = &ne3210_get_8390_hdr;
204 dev->open = &ne3210_open;
205 dev->stop = &ne3210_close;
206 #ifdef CONFIG_NET_POLL_CONTROLLER
207 dev->poll_controller = ei_poll;
208 #endif
209 dev->if_port = ifmap_val[port_index];
211 if ((retval = register_netdev (dev)))
212 goto out5;
214 NS8390_init(dev, 0);
215 return 0;
217 out5:
218 iounmap(ei_status.mem);
219 out4:
220 release_mem_region (phys_mem, NE3210_STOP_PG*0x100);
221 out3:
222 free_irq (dev->irq, dev);
223 out2:
224 release_region (ioaddr + NE3210_CFG1, NE3210_CFG_EXTENT);
225 out1:
226 release_region (ioaddr, NE3210_IO_EXTENT);
227 out:
228 free_netdev (dev);
230 return retval;
231 }
233 static int __devexit ne3210_eisa_remove (struct device *device)
234 {
235 struct net_device *dev = device->driver_data;
236 unsigned long ioaddr = to_eisa_device (device)->base_addr;
238 unregister_netdev (dev);
239 iounmap(ei_status.mem);
240 release_mem_region (ei_status.priv, NE3210_STOP_PG*0x100);
241 free_irq (dev->irq, dev);
242 release_region (ioaddr + NE3210_CFG1, NE3210_CFG_EXTENT);
243 release_region (ioaddr, NE3210_IO_EXTENT);
244 free_netdev (dev);
246 return 0;
247 }
249 /*
250 * Reset by toggling the "Board Enable" bits (bit 2 and 0).
251 */
253 static void ne3210_reset_8390(struct net_device *dev)
254 {
255 unsigned short ioaddr = dev->base_addr;
257 outb(0x04, ioaddr + NE3210_RESET_PORT);
258 if (ei_debug > 1) printk("%s: resetting the NE3210...", dev->name);
260 mdelay(2);
262 ei_status.txing = 0;
263 outb(0x01, ioaddr + NE3210_RESET_PORT);
264 if (ei_debug > 1) printk("reset done\n");
266 return;
267 }
269 /*
270 * Note: In the following three functions is the implicit assumption
271 * that the associated memcpy will only use "rep; movsl" as long as
272 * we keep the counts as some multiple of doublewords. This is a
273 * requirement of the hardware, and also prevents us from using
274 * eth_io_copy_and_sum() since we can't guarantee it will limit
275 * itself to doubleword access.
276 */
278 /*
279 * Grab the 8390 specific header. Similar to the block_input routine, but
280 * we don't need to be concerned with ring wrap as the header will be at
281 * the start of a page, so we optimize accordingly. (A single doubleword.)
282 */
284 static void
285 ne3210_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
286 {
287 void __iomem *hdr_start = ei_status.mem + ((ring_page - NE3210_START_PG)<<8);
288 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
289 hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
290 }
292 /*
293 * Block input and output are easy on shared memory ethercards, the only
294 * complication is when the ring buffer wraps. The count will already
295 * be rounded up to a doubleword value via ne3210_get_8390_hdr() above.
296 */
298 static void ne3210_block_input(struct net_device *dev, int count, struct sk_buff *skb,
299 int ring_offset)
300 {
301 void __iomem *start = ei_status.mem + ring_offset - NE3210_START_PG*256;
303 if (ring_offset + count > NE3210_STOP_PG*256) {
304 /* Packet wraps over end of ring buffer. */
305 int semi_count = NE3210_STOP_PG*256 - ring_offset;
306 memcpy_fromio(skb->data, start, semi_count);
307 count -= semi_count;
308 memcpy_fromio(skb->data + semi_count,
309 ei_status.mem + TX_PAGES*256, count);
310 } else {
311 /* Packet is in one chunk. */
312 memcpy_fromio(skb->data, start, count);
313 }
314 }
316 static void ne3210_block_output(struct net_device *dev, int count,
317 const unsigned char *buf, int start_page)
318 {
319 void __iomem *shmem = ei_status.mem + ((start_page - NE3210_START_PG)<<8);
321 count = (count + 3) & ~3; /* Round up to doubleword */
322 memcpy_toio(shmem, buf, count);
323 }
325 static int ne3210_open(struct net_device *dev)
326 {
327 ei_open(dev);
328 return 0;
329 }
331 static int ne3210_close(struct net_device *dev)
332 {
334 if (ei_debug > 1)
335 printk("%s: Shutting down ethercard.\n", dev->name);
337 ei_close(dev);
338 return 0;
339 }
341 static struct eisa_device_id ne3210_ids[] = {
342 { "EGL0101" },
343 { "NVL1801" },
344 { "" },
345 };
347 static struct eisa_driver ne3210_eisa_driver = {
348 .id_table = ne3210_ids,
349 .driver = {
350 .name = "ne3210",
351 .probe = ne3210_eisa_probe,
352 .remove = __devexit_p (ne3210_eisa_remove),
353 },
354 };
356 MODULE_DESCRIPTION("NE3210 EISA Ethernet driver");
357 MODULE_LICENSE("GPL");
358 MODULE_DEVICE_TABLE(eisa, ne3210_ids);
360 static int ne3210_init(void)
361 {
362 return eisa_driver_register (&ne3210_eisa_driver);
363 }
365 static void ne3210_cleanup(void)
366 {
367 eisa_driver_unregister (&ne3210_eisa_driver);
368 }
370 module_init (ne3210_init);
371 module_exit (ne3210_cleanup);