ia64/linux-2.6.18-xen.hg

view drivers/net/apne.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 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
3 *
4 * (C) Copyright 1997 Alain Malek
5 * (Alain.Malek@cryogen.com)
6 *
7 * ----------------------------------------------------------------------------
8 *
9 * This program is based on
10 *
11 * ne.c: A general non-shared-memory NS8390 ethernet driver for linux
12 * Written 1992-94 by Donald Becker.
13 *
14 * 8390.c: A general NS8390 ethernet driver core for linux.
15 * Written 1992-94 by Donald Becker.
16 *
17 * cnetdevice: A Sana-II ethernet driver for AmigaOS
18 * Written by Bruce Abbott (bhabbott@inhb.co.nz)
19 *
20 * ----------------------------------------------------------------------------
21 *
22 * This file is subject to the terms and conditions of the GNU General Public
23 * License. See the file COPYING in the main directory of the Linux
24 * distribution for more details.
25 *
26 * ----------------------------------------------------------------------------
27 *
28 */
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/pci.h>
35 #include <linux/init.h>
36 #include <linux/delay.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/jiffies.h>
41 #include <asm/system.h>
42 #include <asm/io.h>
43 #include <asm/setup.h>
44 #include <asm/amigaints.h>
45 #include <asm/amigahw.h>
46 #include <asm/amigayle.h>
47 #include <asm/amipcmcia.h>
49 #include "8390.h"
51 /* ---- No user-serviceable parts below ---- */
53 #define DRV_NAME "apne"
55 #define NE_BASE (dev->base_addr)
56 #define NE_CMD 0x00
57 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
58 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
59 #define NE_IO_EXTENT 0x20
61 #define NE_EN0_ISR 0x07
62 #define NE_EN0_DCFG 0x0e
64 #define NE_EN0_RSARLO 0x08
65 #define NE_EN0_RSARHI 0x09
66 #define NE_EN0_RCNTLO 0x0a
67 #define NE_EN0_RXCR 0x0c
68 #define NE_EN0_TXCR 0x0d
69 #define NE_EN0_RCNTHI 0x0b
70 #define NE_EN0_IMR 0x0f
72 #define NE1SM_START_PG 0x20 /* First page of TX buffer */
73 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
74 #define NESM_START_PG 0x40 /* First page of TX buffer */
75 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
78 struct net_device * __init apne_probe(int unit);
79 static int apne_probe1(struct net_device *dev, int ioaddr);
81 static int apne_open(struct net_device *dev);
82 static int apne_close(struct net_device *dev);
84 static void apne_reset_8390(struct net_device *dev);
85 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
86 int ring_page);
87 static void apne_block_input(struct net_device *dev, int count,
88 struct sk_buff *skb, int ring_offset);
89 static void apne_block_output(struct net_device *dev, const int count,
90 const unsigned char *buf, const int start_page);
91 static irqreturn_t apne_interrupt(int irq, void *dev_id, struct pt_regs *regs);
93 static int init_pcmcia(void);
95 /* IO base address used for nic */
97 #define IOBASE 0x300
99 /*
100 use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
101 you can find the values to use by looking at the cnet.device
102 config file example (the default values are for the CNET40BC card)
103 */
105 /*
106 #define MANUAL_CONFIG 0x20
107 #define MANUAL_OFFSET 0x3f8
109 #define MANUAL_HWADDR0 0x00
110 #define MANUAL_HWADDR1 0x12
111 #define MANUAL_HWADDR2 0x34
112 #define MANUAL_HWADDR3 0x56
113 #define MANUAL_HWADDR4 0x78
114 #define MANUAL_HWADDR5 0x9a
115 */
117 static const char version[] =
118 "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
120 static int apne_owned; /* signal if card already owned */
122 struct net_device * __init apne_probe(int unit)
123 {
124 struct net_device *dev;
125 #ifndef MANUAL_CONFIG
126 char tuple[8];
127 #endif
128 int err;
130 if (apne_owned)
131 return ERR_PTR(-ENODEV);
133 if ( !(AMIGAHW_PRESENT(PCMCIA)) )
134 return ERR_PTR(-ENODEV);
136 printk("Looking for PCMCIA ethernet card : ");
138 /* check if a card is inserted */
139 if (!(PCMCIA_INSERTED)) {
140 printk("NO PCMCIA card inserted\n");
141 return ERR_PTR(-ENODEV);
142 }
144 dev = alloc_ei_netdev();
145 if (!dev)
146 return ERR_PTR(-ENOMEM);
147 if (unit >= 0) {
148 sprintf(dev->name, "eth%d", unit);
149 netdev_boot_setup_check(dev);
150 }
151 SET_MODULE_OWNER(dev);
153 /* disable pcmcia irq for readtuple */
154 pcmcia_disable_irq();
156 #ifndef MANUAL_CONFIG
157 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
158 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
159 printk("not an ethernet card\n");
160 /* XXX: shouldn't we re-enable irq here? */
161 free_netdev(dev);
162 return ERR_PTR(-ENODEV);
163 }
164 #endif
166 printk("ethernet PCMCIA card inserted\n");
168 if (!init_pcmcia()) {
169 /* XXX: shouldn't we re-enable irq here? */
170 free_netdev(dev);
171 return ERR_PTR(-ENODEV);
172 }
174 if (!request_region(IOBASE, 0x20, DRV_NAME)) {
175 free_netdev(dev);
176 return ERR_PTR(-EBUSY);
177 }
179 err = apne_probe1(dev, IOBASE);
180 if (err) {
181 release_region(IOBASE, 0x20);
182 free_netdev(dev);
183 return ERR_PTR(err);
184 }
185 err = register_netdev(dev);
186 if (!err)
187 return dev;
189 pcmcia_disable_irq();
190 free_irq(IRQ_AMIGA_PORTS, dev);
191 pcmcia_reset();
192 release_region(IOBASE, 0x20);
193 free_netdev(dev);
194 return ERR_PTR(err);
195 }
197 static int __init apne_probe1(struct net_device *dev, int ioaddr)
198 {
199 int i;
200 unsigned char SA_prom[32];
201 int wordlength = 2;
202 const char *name = NULL;
203 int start_page, stop_page;
204 #ifndef MANUAL_HWADDR0
205 int neX000, ctron;
206 #endif
207 static unsigned version_printed;
209 if (ei_debug && version_printed++ == 0)
210 printk(version);
212 printk("PCMCIA NE*000 ethercard probe");
214 /* Reset card. Who knows what dain-bramaged state it was left in. */
215 { unsigned long reset_start_time = jiffies;
217 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
219 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
220 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
221 printk(" not found (no reset ack).\n");
222 return -ENODEV;
223 }
225 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
226 }
228 #ifndef MANUAL_HWADDR0
230 /* Read the 16 bytes of station address PROM.
231 We must first initialize registers, similar to NS8390_init(eifdev, 0).
232 We can't reliably read the SAPROM address without this.
233 (I learned the hard way!). */
234 {
235 struct {unsigned long value, offset; } program_seq[] = {
236 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
237 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
238 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
239 {0x00, NE_EN0_RCNTHI},
240 {0x00, NE_EN0_IMR}, /* Mask completion irq. */
241 {0xFF, NE_EN0_ISR},
242 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
243 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
244 {32, NE_EN0_RCNTLO},
245 {0x00, NE_EN0_RCNTHI},
246 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
247 {0x00, NE_EN0_RSARHI},
248 {E8390_RREAD+E8390_START, NE_CMD},
249 };
250 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) {
251 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
252 }
254 }
255 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
256 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
257 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
258 if (SA_prom[i] != SA_prom[i+1])
259 wordlength = 1;
260 }
262 /* At this point, wordlength *only* tells us if the SA_prom is doubled
263 up or not because some broken PCI cards don't respect the byte-wide
264 request in program_seq above, and hence don't have doubled up values.
265 These broken cards would otherwise be detected as an ne1000. */
267 if (wordlength == 2)
268 for (i = 0; i < 16; i++)
269 SA_prom[i] = SA_prom[i+i];
271 if (wordlength == 2) {
272 /* We must set the 8390 for word mode. */
273 outb(0x49, ioaddr + NE_EN0_DCFG);
274 start_page = NESM_START_PG;
275 stop_page = NESM_STOP_PG;
276 } else {
277 start_page = NE1SM_START_PG;
278 stop_page = NE1SM_STOP_PG;
279 }
281 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
282 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
284 /* Set up the rest of the parameters. */
285 if (neX000) {
286 name = (wordlength == 2) ? "NE2000" : "NE1000";
287 } else if (ctron) {
288 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
289 start_page = 0x01;
290 stop_page = (wordlength == 2) ? 0x40 : 0x20;
291 } else {
292 printk(" not found.\n");
293 return -ENXIO;
295 }
297 #else
298 wordlength = 2;
299 /* We must set the 8390 for word mode. */
300 outb(0x49, ioaddr + NE_EN0_DCFG);
301 start_page = NESM_START_PG;
302 stop_page = NESM_STOP_PG;
304 SA_prom[0] = MANUAL_HWADDR0;
305 SA_prom[1] = MANUAL_HWADDR1;
306 SA_prom[2] = MANUAL_HWADDR2;
307 SA_prom[3] = MANUAL_HWADDR3;
308 SA_prom[4] = MANUAL_HWADDR4;
309 SA_prom[5] = MANUAL_HWADDR5;
310 name = "NE2000";
311 #endif
313 dev->base_addr = ioaddr;
315 /* Install the Interrupt handler */
316 i = request_irq(IRQ_AMIGA_PORTS, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
317 if (i) return i;
319 for(i = 0; i < ETHER_ADDR_LEN; i++) {
320 printk(" %2.2x", SA_prom[i]);
321 dev->dev_addr[i] = SA_prom[i];
322 }
324 printk("\n%s: %s found.\n", dev->name, name);
326 ei_status.name = name;
327 ei_status.tx_start_page = start_page;
328 ei_status.stop_page = stop_page;
329 ei_status.word16 = (wordlength == 2);
331 ei_status.rx_start_page = start_page + TX_PAGES;
333 ei_status.reset_8390 = &apne_reset_8390;
334 ei_status.block_input = &apne_block_input;
335 ei_status.block_output = &apne_block_output;
336 ei_status.get_8390_hdr = &apne_get_8390_hdr;
337 dev->open = &apne_open;
338 dev->stop = &apne_close;
339 #ifdef CONFIG_NET_POLL_CONTROLLER
340 dev->poll_controller = ei_poll;
341 #endif
342 NS8390_init(dev, 0);
344 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
345 pcmcia_enable_irq();
347 apne_owned = 1;
349 return 0;
350 }
352 static int
353 apne_open(struct net_device *dev)
354 {
355 ei_open(dev);
356 return 0;
357 }
359 static int
360 apne_close(struct net_device *dev)
361 {
362 if (ei_debug > 1)
363 printk("%s: Shutting down ethercard.\n", dev->name);
364 ei_close(dev);
365 return 0;
366 }
368 /* Hard reset the card. This used to pause for the same period that a
369 8390 reset command required, but that shouldn't be necessary. */
370 static void
371 apne_reset_8390(struct net_device *dev)
372 {
373 unsigned long reset_start_time = jiffies;
375 init_pcmcia();
377 if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
379 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
381 ei_status.txing = 0;
382 ei_status.dmaing = 0;
384 /* This check _should_not_ be necessary, omit eventually. */
385 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
386 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
387 printk("%s: ne_reset_8390() did not complete.\n", dev->name);
388 break;
389 }
390 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
391 }
393 /* Grab the 8390 specific header. Similar to the block_input routine, but
394 we don't need to be concerned with ring wrap as the header will be at
395 the start of a page, so we optimize accordingly. */
397 static void
398 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
399 {
401 int nic_base = dev->base_addr;
402 int cnt;
403 char *ptrc;
404 short *ptrs;
406 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
407 if (ei_status.dmaing) {
408 printk("%s: DMAing conflict in ne_get_8390_hdr "
409 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
410 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
411 return;
412 }
414 ei_status.dmaing |= 0x01;
415 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
416 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
417 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
418 outb(0, nic_base + NE_EN0_RCNTHI);
419 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
420 outb(ring_page, nic_base + NE_EN0_RSARHI);
421 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
423 if (ei_status.word16) {
424 ptrs = (short*)hdr;
425 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
426 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
427 } else {
428 ptrc = (char*)hdr;
429 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
430 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
431 }
433 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
434 ei_status.dmaing &= ~0x01;
436 le16_to_cpus(&hdr->count);
437 }
439 /* Block input and output, similar to the Crynwr packet driver. If you
440 are porting to a new ethercard, look at the packet driver source for hints.
441 The NEx000 doesn't share the on-board packet memory -- you have to put
442 the packet out through the "remote DMA" dataport using outb. */
444 static void
445 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
446 {
447 int nic_base = dev->base_addr;
448 char *buf = skb->data;
449 char *ptrc;
450 short *ptrs;
451 int cnt;
453 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
454 if (ei_status.dmaing) {
455 printk("%s: DMAing conflict in ne_block_input "
456 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
457 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
458 return;
459 }
460 ei_status.dmaing |= 0x01;
461 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
462 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
463 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
464 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
465 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
466 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
467 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
468 if (ei_status.word16) {
469 ptrs = (short*)buf;
470 for (cnt = 0; cnt < (count>>1); cnt++)
471 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
472 if (count & 0x01) {
473 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
474 }
475 } else {
476 ptrc = (char*)buf;
477 for (cnt = 0; cnt < count; cnt++)
478 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
479 }
481 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
482 ei_status.dmaing &= ~0x01;
483 }
485 static void
486 apne_block_output(struct net_device *dev, int count,
487 const unsigned char *buf, const int start_page)
488 {
489 int nic_base = NE_BASE;
490 unsigned long dma_start;
491 char *ptrc;
492 short *ptrs;
493 int cnt;
495 /* Round the count up for word writes. Do we need to do this?
496 What effect will an odd byte count have on the 8390?
497 I should check someday. */
498 if (ei_status.word16 && (count & 0x01))
499 count++;
501 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
502 if (ei_status.dmaing) {
503 printk("%s: DMAing conflict in ne_block_output."
504 "[DMAstat:%d][irqlock:%d][intr:%d]\n",
505 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
506 return;
507 }
508 ei_status.dmaing |= 0x01;
509 /* We should already be in page 0, but to be safe... */
510 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
512 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
514 /* Now the normal output. */
515 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
516 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
517 outb(0x00, nic_base + NE_EN0_RSARLO);
518 outb(start_page, nic_base + NE_EN0_RSARHI);
520 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
521 if (ei_status.word16) {
522 ptrs = (short*)buf;
523 for (cnt = 0; cnt < count>>1; cnt++)
524 outw(*ptrs++, NE_BASE+NE_DATAPORT);
525 } else {
526 ptrc = (char*)buf;
527 for (cnt = 0; cnt < count; cnt++)
528 outb(*ptrc++, NE_BASE + NE_DATAPORT);
529 }
531 dma_start = jiffies;
533 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
534 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
535 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
536 apne_reset_8390(dev);
537 NS8390_init(dev,1);
538 break;
539 }
541 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
542 ei_status.dmaing &= ~0x01;
543 return;
544 }
546 static irqreturn_t apne_interrupt(int irq, void *dev_id, struct pt_regs *regs)
547 {
548 unsigned char pcmcia_intreq;
550 if (!(gayle.inten & GAYLE_IRQ_IRQ))
551 return IRQ_NONE;
553 pcmcia_intreq = pcmcia_get_intreq();
555 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
556 pcmcia_ack_int(pcmcia_intreq);
557 return IRQ_NONE;
558 }
559 if (ei_debug > 3)
560 printk("pcmcia intreq = %x\n", pcmcia_intreq);
561 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
562 ei_interrupt(irq, dev_id, regs);
563 pcmcia_ack_int(pcmcia_get_intreq());
564 pcmcia_enable_irq();
565 return IRQ_HANDLED;
566 }
568 #ifdef MODULE
569 static struct net_device *apne_dev;
571 int init_module(void)
572 {
573 apne_dev = apne_probe(-1);
574 if (IS_ERR(apne_dev))
575 return PTR_ERR(apne_dev);
576 return 0;
577 }
579 void cleanup_module(void)
580 {
581 unregister_netdev(apne_dev);
583 pcmcia_disable_irq();
585 free_irq(IRQ_AMIGA_PORTS, apne_dev);
587 pcmcia_reset();
589 release_region(IOBASE, 0x20);
591 free_netdev(apne_dev);
592 }
594 #endif
596 static int init_pcmcia(void)
597 {
598 u_char config;
599 #ifndef MANUAL_CONFIG
600 u_char tuple[32];
601 int offset_len;
602 #endif
603 u_long offset;
605 pcmcia_reset();
606 pcmcia_program_voltage(PCMCIA_0V);
607 pcmcia_access_speed(PCMCIA_SPEED_250NS);
608 pcmcia_write_enable();
610 #ifdef MANUAL_CONFIG
611 config = MANUAL_CONFIG;
612 #else
613 /* get and write config byte to enable IO port */
615 if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
616 return 0;
618 config = tuple[2] & 0x3f;
619 #endif
620 #ifdef MANUAL_OFFSET
621 offset = MANUAL_OFFSET;
622 #else
623 if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
624 return 0;
626 offset_len = (tuple[2] & 0x3) + 1;
627 offset = 0;
628 while(offset_len--) {
629 offset = (offset << 8) | tuple[4+offset_len];
630 }
631 #endif
633 out_8(GAYLE_ATTRIBUTE+offset, config);
635 return 1;
636 }
638 MODULE_LICENSE("GPL");