ia64/linux-2.6.18-xen.hg

view drivers/acpi/pci_link.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 2afa279661de
children
line source
1 /*
2 * pci_link.c - ACPI PCI Interrupt Link Device Driver ($Revision: 34 $)
3 *
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 * Copyright (C) 2002 Dominik Brodowski <devel@brodo.de>
7 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 *
26 * TBD:
27 * 1. Support more than one IRQ resource entry per link device (index).
28 * 2. Implement start/stop mechanism and use ACPI Bus Driver facilities
29 * for IRQ management (e.g. start()->_SRS).
30 */
32 #include <linux/sysdev.h>
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/types.h>
37 #include <linux/proc_fs.h>
38 #include <linux/spinlock.h>
39 #include <linux/pm.h>
40 #include <linux/pci.h>
41 #include <linux/mutex.h>
43 #include <acpi/acpi_bus.h>
44 #include <acpi/acpi_drivers.h>
46 #define _COMPONENT ACPI_PCI_COMPONENT
47 ACPI_MODULE_NAME("pci_link")
48 #define ACPI_PCI_LINK_CLASS "pci_irq_routing"
49 #define ACPI_PCI_LINK_HID "PNP0C0F"
50 #define ACPI_PCI_LINK_DRIVER_NAME "ACPI PCI Interrupt Link Driver"
51 #define ACPI_PCI_LINK_DEVICE_NAME "PCI Interrupt Link"
52 #define ACPI_PCI_LINK_FILE_INFO "info"
53 #define ACPI_PCI_LINK_FILE_STATUS "state"
54 #define ACPI_PCI_LINK_MAX_POSSIBLE 16
55 static int acpi_pci_link_add(struct acpi_device *device);
56 static int acpi_pci_link_remove(struct acpi_device *device, int type);
58 static struct acpi_driver acpi_pci_link_driver = {
59 .name = ACPI_PCI_LINK_DRIVER_NAME,
60 .class = ACPI_PCI_LINK_CLASS,
61 .ids = ACPI_PCI_LINK_HID,
62 .ops = {
63 .add = acpi_pci_link_add,
64 .remove = acpi_pci_link_remove,
65 },
66 };
68 /*
69 * If a link is initialized, we never change its active and initialized
70 * later even the link is disable. Instead, we just repick the active irq
71 */
72 struct acpi_pci_link_irq {
73 u8 active; /* Current IRQ */
74 u8 triggering; /* All IRQs */
75 u8 polarity; /* All IRQs */
76 u8 resource_type;
77 u8 possible_count;
78 u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
79 u8 initialized:1;
80 u8 reserved:7;
81 };
83 struct acpi_pci_link {
84 struct list_head node;
85 struct acpi_device *device;
86 struct acpi_pci_link_irq irq;
87 int refcnt;
88 };
90 static struct {
91 int count;
92 struct list_head entries;
93 } acpi_link;
94 DEFINE_MUTEX(acpi_link_lock);
96 /* --------------------------------------------------------------------------
97 PCI Link Device Management
98 -------------------------------------------------------------------------- */
100 /*
101 * set context (link) possible list from resource list
102 */
103 static acpi_status
104 acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
105 {
106 struct acpi_pci_link *link = (struct acpi_pci_link *)context;
107 u32 i = 0;
110 switch (resource->type) {
111 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
112 return AE_OK;
113 case ACPI_RESOURCE_TYPE_IRQ:
114 {
115 struct acpi_resource_irq *p = &resource->data.irq;
116 if (!p || !p->interrupt_count) {
117 printk(KERN_WARNING PREFIX "Blank IRQ resource\n");
118 return AE_OK;
119 }
120 for (i = 0;
121 (i < p->interrupt_count
122 && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
123 if (!p->interrupts[i]) {
124 printk(KERN_WARNING PREFIX "Invalid IRQ %d\n",
125 p->interrupts[i]);
126 continue;
127 }
128 link->irq.possible[i] = p->interrupts[i];
129 link->irq.possible_count++;
130 }
131 link->irq.triggering = p->triggering;
132 link->irq.polarity = p->polarity;
133 link->irq.resource_type = ACPI_RESOURCE_TYPE_IRQ;
134 break;
135 }
136 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
137 {
138 struct acpi_resource_extended_irq *p =
139 &resource->data.extended_irq;
140 if (!p || !p->interrupt_count) {
141 printk(KERN_WARNING PREFIX
142 "Blank EXT IRQ resource\n");
143 return AE_OK;
144 }
145 for (i = 0;
146 (i < p->interrupt_count
147 && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
148 if (!p->interrupts[i]) {
149 printk(KERN_WARNING PREFIX "Invalid IRQ %d\n",
150 p->interrupts[i]);
151 continue;
152 }
153 link->irq.possible[i] = p->interrupts[i];
154 link->irq.possible_count++;
155 }
156 link->irq.triggering = p->triggering;
157 link->irq.polarity = p->polarity;
158 link->irq.resource_type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
159 break;
160 }
161 default:
162 printk(KERN_ERR PREFIX "Resource is not an IRQ entry\n");
163 return AE_OK;
164 }
166 return AE_CTRL_TERMINATE;
167 }
169 static int acpi_pci_link_get_possible(struct acpi_pci_link *link)
170 {
171 acpi_status status;
174 if (!link)
175 return -EINVAL;
177 status = acpi_walk_resources(link->device->handle, METHOD_NAME__PRS,
178 acpi_pci_link_check_possible, link);
179 if (ACPI_FAILURE(status)) {
180 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRS"));
181 return -ENODEV;
182 }
184 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
185 "Found %d possible IRQs\n",
186 link->irq.possible_count));
188 return 0;
189 }
191 static acpi_status
192 acpi_pci_link_check_current(struct acpi_resource *resource, void *context)
193 {
194 int *irq = (int *)context;
197 switch (resource->type) {
198 case ACPI_RESOURCE_TYPE_IRQ:
199 {
200 struct acpi_resource_irq *p = &resource->data.irq;
201 if (!p || !p->interrupt_count) {
202 /*
203 * IRQ descriptors may have no IRQ# bits set,
204 * particularly those those w/ _STA disabled
205 */
206 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
207 "Blank IRQ resource\n"));
208 return AE_OK;
209 }
210 *irq = p->interrupts[0];
211 break;
212 }
213 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
214 {
215 struct acpi_resource_extended_irq *p =
216 &resource->data.extended_irq;
217 if (!p || !p->interrupt_count) {
218 /*
219 * extended IRQ descriptors must
220 * return at least 1 IRQ
221 */
222 printk(KERN_WARNING PREFIX
223 "Blank EXT IRQ resource\n");
224 return AE_OK;
225 }
226 *irq = p->interrupts[0];
227 break;
228 }
229 break;
230 default:
231 printk(KERN_ERR PREFIX "Resource %d isn't an IRQ\n", resource->type);
232 case ACPI_RESOURCE_TYPE_END_TAG:
233 return AE_OK;
234 }
235 return AE_CTRL_TERMINATE;
236 }
238 /*
239 * Run _CRS and set link->irq.active
240 *
241 * return value:
242 * 0 - success
243 * !0 - failure
244 */
245 static int acpi_pci_link_get_current(struct acpi_pci_link *link)
246 {
247 int result = 0;
248 acpi_status status = AE_OK;
249 int irq = 0;
251 if (!link)
252 return -EINVAL;
254 link->irq.active = 0;
256 /* in practice, status disabled is meaningless, ignore it */
257 if (acpi_strict) {
258 /* Query _STA, set link->device->status */
259 result = acpi_bus_get_status(link->device);
260 if (result) {
261 printk(KERN_ERR PREFIX "Unable to read status\n");
262 goto end;
263 }
265 if (!link->device->status.enabled) {
266 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link disabled\n"));
267 return 0;
268 }
269 }
271 /*
272 * Query and parse _CRS to get the current IRQ assignment.
273 */
275 status = acpi_walk_resources(link->device->handle, METHOD_NAME__CRS,
276 acpi_pci_link_check_current, &irq);
277 if (ACPI_FAILURE(status)) {
278 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _CRS"));
279 result = -ENODEV;
280 goto end;
281 }
283 if (acpi_strict && !irq) {
284 printk(KERN_ERR PREFIX "_CRS returned 0\n");
285 result = -ENODEV;
286 }
288 link->irq.active = irq;
290 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link at IRQ %d \n", link->irq.active));
292 end:
293 return result;
294 }
296 static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
297 {
298 int result = 0;
299 acpi_status status = AE_OK;
300 struct {
301 struct acpi_resource res;
302 struct acpi_resource end;
303 } *resource;
304 struct acpi_buffer buffer = { 0, NULL };
307 if (!link || !irq)
308 return -EINVAL;
310 resource = kmalloc(sizeof(*resource) + 1, GFP_ATOMIC);
311 if (!resource)
312 return -ENOMEM;
314 memset(resource, 0, sizeof(*resource) + 1);
315 buffer.length = sizeof(*resource) + 1;
316 buffer.pointer = resource;
318 switch (link->irq.resource_type) {
319 case ACPI_RESOURCE_TYPE_IRQ:
320 resource->res.type = ACPI_RESOURCE_TYPE_IRQ;
321 resource->res.length = sizeof(struct acpi_resource);
322 resource->res.data.irq.triggering = link->irq.triggering;
323 resource->res.data.irq.polarity =
324 link->irq.polarity;
325 if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
326 resource->res.data.irq.sharable =
327 ACPI_EXCLUSIVE;
328 else
329 resource->res.data.irq.sharable = ACPI_SHARED;
330 resource->res.data.irq.interrupt_count = 1;
331 resource->res.data.irq.interrupts[0] = irq;
332 break;
334 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
335 resource->res.type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
336 resource->res.length = sizeof(struct acpi_resource);
337 resource->res.data.extended_irq.producer_consumer =
338 ACPI_CONSUMER;
339 resource->res.data.extended_irq.triggering =
340 link->irq.triggering;
341 resource->res.data.extended_irq.polarity =
342 link->irq.polarity;
343 if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
344 resource->res.data.irq.sharable =
345 ACPI_EXCLUSIVE;
346 else
347 resource->res.data.irq.sharable = ACPI_SHARED;
348 resource->res.data.extended_irq.interrupt_count = 1;
349 resource->res.data.extended_irq.interrupts[0] = irq;
350 /* ignore resource_source, it's optional */
351 break;
352 default:
353 printk(KERN_ERR PREFIX "Invalid Resource_type %d\n", link->irq.resource_type);
354 result = -EINVAL;
355 goto end;
357 }
358 resource->end.type = ACPI_RESOURCE_TYPE_END_TAG;
360 /* Attempt to set the resource */
361 status = acpi_set_current_resources(link->device->handle, &buffer);
363 /* check for total failure */
364 if (ACPI_FAILURE(status)) {
365 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SRS"));
366 result = -ENODEV;
367 goto end;
368 }
370 /* Query _STA, set device->status */
371 result = acpi_bus_get_status(link->device);
372 if (result) {
373 printk(KERN_ERR PREFIX "Unable to read status\n");
374 goto end;
375 }
376 if (!link->device->status.enabled) {
377 printk(KERN_WARNING PREFIX
378 "%s [%s] disabled and referenced, BIOS bug\n",
379 acpi_device_name(link->device),
380 acpi_device_bid(link->device));
381 }
383 /* Query _CRS, set link->irq.active */
384 result = acpi_pci_link_get_current(link);
385 if (result) {
386 goto end;
387 }
389 /*
390 * Is current setting not what we set?
391 * set link->irq.active
392 */
393 if (link->irq.active != irq) {
394 /*
395 * policy: when _CRS doesn't return what we just _SRS
396 * assume _SRS worked and override _CRS value.
397 */
398 printk(KERN_WARNING PREFIX
399 "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
400 acpi_device_name(link->device),
401 acpi_device_bid(link->device), link->irq.active, irq);
402 link->irq.active = irq;
403 }
405 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Set IRQ %d\n", link->irq.active));
407 end:
408 kfree(resource);
409 return result;
410 }
412 /* --------------------------------------------------------------------------
413 PCI Link IRQ Management
414 -------------------------------------------------------------------------- */
416 /*
417 * "acpi_irq_balance" (default in APIC mode) enables ACPI to use PIC Interrupt
418 * Link Devices to move the PIRQs around to minimize sharing.
419 *
420 * "acpi_irq_nobalance" (default in PIC mode) tells ACPI not to move any PIC IRQs
421 * that the BIOS has already set to active. This is necessary because
422 * ACPI has no automatic means of knowing what ISA IRQs are used. Note that
423 * if the BIOS doesn't set a Link Device active, ACPI needs to program it
424 * even if acpi_irq_nobalance is set.
425 *
426 * A tables of penalties avoids directing PCI interrupts to well known
427 * ISA IRQs. Boot params are available to over-ride the default table:
428 *
429 * List interrupts that are free for PCI use.
430 * acpi_irq_pci=n[,m]
431 *
432 * List interrupts that should not be used for PCI:
433 * acpi_irq_isa=n[,m]
434 *
435 * Note that PCI IRQ routers have a list of possible IRQs,
436 * which may not include the IRQs this table says are available.
437 *
438 * Since this heuristic can't tell the difference between a link
439 * that no device will attach to, vs. a link which may be shared
440 * by multiple active devices -- it is not optimal.
441 *
442 * If interrupt performance is that important, get an IO-APIC system
443 * with a pin dedicated to each device. Or for that matter, an MSI
444 * enabled system.
445 */
447 #define ACPI_MAX_IRQS 256
448 #define ACPI_MAX_ISA_IRQ 16
450 #define PIRQ_PENALTY_PCI_AVAILABLE (0)
451 #define PIRQ_PENALTY_PCI_POSSIBLE (16*16)
452 #define PIRQ_PENALTY_PCI_USING (16*16*16)
453 #define PIRQ_PENALTY_ISA_TYPICAL (16*16*16*16)
454 #define PIRQ_PENALTY_ISA_USED (16*16*16*16*16)
455 #define PIRQ_PENALTY_ISA_ALWAYS (16*16*16*16*16*16)
457 static int acpi_irq_penalty[ACPI_MAX_IRQS] = {
458 PIRQ_PENALTY_ISA_ALWAYS, /* IRQ0 timer */
459 PIRQ_PENALTY_ISA_ALWAYS, /* IRQ1 keyboard */
460 PIRQ_PENALTY_ISA_ALWAYS, /* IRQ2 cascade */
461 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ3 serial */
462 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ4 serial */
463 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ5 sometimes SoundBlaster */
464 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ6 */
465 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ7 parallel, spurious */
466 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ8 rtc, sometimes */
467 PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ9 PCI, often acpi */
468 PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ10 PCI */
469 PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ11 PCI */
470 PIRQ_PENALTY_ISA_USED, /* IRQ12 mouse */
471 PIRQ_PENALTY_ISA_USED, /* IRQ13 fpe, sometimes */
472 PIRQ_PENALTY_ISA_USED, /* IRQ14 ide0 */
473 PIRQ_PENALTY_ISA_USED, /* IRQ15 ide1 */
474 /* >IRQ15 */
475 };
477 int __init acpi_irq_penalty_init(void)
478 {
479 struct list_head *node = NULL;
480 struct acpi_pci_link *link = NULL;
481 int i = 0;
484 /*
485 * Update penalties to facilitate IRQ balancing.
486 */
487 list_for_each(node, &acpi_link.entries) {
489 link = list_entry(node, struct acpi_pci_link, node);
490 if (!link) {
491 printk(KERN_ERR PREFIX "Invalid link context\n");
492 continue;
493 }
495 /*
496 * reflect the possible and active irqs in the penalty table --
497 * useful for breaking ties.
498 */
499 if (link->irq.possible_count) {
500 int penalty =
501 PIRQ_PENALTY_PCI_POSSIBLE /
502 link->irq.possible_count;
504 for (i = 0; i < link->irq.possible_count; i++) {
505 if (link->irq.possible[i] < ACPI_MAX_ISA_IRQ)
506 acpi_irq_penalty[link->irq.
507 possible[i]] +=
508 penalty;
509 }
511 } else if (link->irq.active) {
512 acpi_irq_penalty[link->irq.active] +=
513 PIRQ_PENALTY_PCI_POSSIBLE;
514 }
515 }
516 /* Add a penalty for the SCI */
517 acpi_irq_penalty[acpi_fadt.sci_int] += PIRQ_PENALTY_PCI_USING;
519 return 0;
520 }
522 static int acpi_irq_balance; /* 0: static, 1: balance */
524 static int acpi_pci_link_allocate(struct acpi_pci_link *link)
525 {
526 int irq;
527 int i;
530 if (link->irq.initialized) {
531 if (link->refcnt == 0)
532 /* This means the link is disabled but initialized */
533 acpi_pci_link_set(link, link->irq.active);
534 return 0;
535 }
537 /*
538 * search for active IRQ in list of possible IRQs.
539 */
540 for (i = 0; i < link->irq.possible_count; ++i) {
541 if (link->irq.active == link->irq.possible[i])
542 break;
543 }
544 /*
545 * forget active IRQ that is not in possible list
546 */
547 if (i == link->irq.possible_count) {
548 if (acpi_strict)
549 printk(KERN_WARNING PREFIX "_CRS %d not found"
550 " in _PRS\n", link->irq.active);
551 link->irq.active = 0;
552 }
554 /*
555 * if active found, use it; else pick entry from end of possible list.
556 */
557 if (link->irq.active) {
558 irq = link->irq.active;
559 } else {
560 irq = link->irq.possible[link->irq.possible_count - 1];
561 }
563 if (acpi_irq_balance || !link->irq.active) {
564 /*
565 * Select the best IRQ. This is done in reverse to promote
566 * the use of IRQs 9, 10, 11, and >15.
567 */
568 for (i = (link->irq.possible_count - 1); i >= 0; i--) {
569 if (acpi_irq_penalty[irq] >
570 acpi_irq_penalty[link->irq.possible[i]])
571 irq = link->irq.possible[i];
572 }
573 }
575 /* Attempt to enable the link device at this IRQ. */
576 if (acpi_pci_link_set(link, irq)) {
577 printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. "
578 "Try pci=noacpi or acpi=off\n",
579 acpi_device_name(link->device),
580 acpi_device_bid(link->device));
581 return -ENODEV;
582 } else {
583 acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_USING;
584 printk(PREFIX "%s [%s] enabled at IRQ %d\n",
585 acpi_device_name(link->device),
586 acpi_device_bid(link->device), link->irq.active);
587 }
589 link->irq.initialized = 1;
591 return 0;
592 }
594 /*
595 * acpi_pci_link_allocate_irq
596 * success: return IRQ >= 0
597 * failure: return -1
598 */
600 int
601 acpi_pci_link_allocate_irq(acpi_handle handle,
602 int index,
603 int *triggering, int *polarity, char **name)
604 {
605 int result = 0;
606 struct acpi_device *device = NULL;
607 struct acpi_pci_link *link = NULL;
610 result = acpi_bus_get_device(handle, &device);
611 if (result) {
612 printk(KERN_ERR PREFIX "Invalid link device\n");
613 return -1;
614 }
616 link = (struct acpi_pci_link *)acpi_driver_data(device);
617 if (!link) {
618 printk(KERN_ERR PREFIX "Invalid link context\n");
619 return -1;
620 }
622 /* TBD: Support multiple index (IRQ) entries per Link Device */
623 if (index) {
624 printk(KERN_ERR PREFIX "Invalid index %d\n", index);
625 return -1;
626 }
628 mutex_lock(&acpi_link_lock);
629 if (acpi_pci_link_allocate(link)) {
630 mutex_unlock(&acpi_link_lock);
631 return -1;
632 }
634 if (!link->irq.active) {
635 mutex_unlock(&acpi_link_lock);
636 printk(KERN_ERR PREFIX "Link active IRQ is 0!\n");
637 return -1;
638 }
639 link->refcnt++;
640 mutex_unlock(&acpi_link_lock);
642 if (triggering)
643 *triggering = link->irq.triggering;
644 if (polarity)
645 *polarity = link->irq.polarity;
646 if (name)
647 *name = acpi_device_bid(link->device);
648 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
649 "Link %s is referenced\n",
650 acpi_device_bid(link->device)));
651 return (link->irq.active);
652 }
654 /*
655 * We don't change link's irq information here. After it is reenabled, we
656 * continue use the info
657 */
658 int acpi_pci_link_free_irq(acpi_handle handle)
659 {
660 struct acpi_device *device = NULL;
661 struct acpi_pci_link *link = NULL;
662 acpi_status result;
665 result = acpi_bus_get_device(handle, &device);
666 if (result) {
667 printk(KERN_ERR PREFIX "Invalid link device\n");
668 return -1;
669 }
671 link = (struct acpi_pci_link *)acpi_driver_data(device);
672 if (!link) {
673 printk(KERN_ERR PREFIX "Invalid link context\n");
674 return -1;
675 }
677 mutex_lock(&acpi_link_lock);
678 if (!link->irq.initialized) {
679 mutex_unlock(&acpi_link_lock);
680 printk(KERN_ERR PREFIX "Link isn't initialized\n");
681 return -1;
682 }
683 #ifdef FUTURE_USE
684 /*
685 * The Link reference count allows us to _DISable an unused link
686 * and suspend time, and set it again on resume.
687 * However, 2.6.12 still has irq_router.resume
688 * which blindly restores the link state.
689 * So we disable the reference count method
690 * to prevent duplicate acpi_pci_link_set()
691 * which would harm some systems
692 */
693 link->refcnt--;
694 #endif
695 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
696 "Link %s is dereferenced\n",
697 acpi_device_bid(link->device)));
699 if (link->refcnt == 0) {
700 acpi_ut_evaluate_object(link->device->handle, "_DIS", 0, NULL);
701 }
702 mutex_unlock(&acpi_link_lock);
703 return (link->irq.active);
704 }
706 /* --------------------------------------------------------------------------
707 Driver Interface
708 -------------------------------------------------------------------------- */
710 static int acpi_pci_link_add(struct acpi_device *device)
711 {
712 int result = 0;
713 struct acpi_pci_link *link = NULL;
714 int i = 0;
715 int found = 0;
718 if (!device)
719 return -EINVAL;
721 link = kmalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
722 if (!link)
723 return -ENOMEM;
724 memset(link, 0, sizeof(struct acpi_pci_link));
726 link->device = device;
727 strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
728 strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
729 acpi_driver_data(device) = link;
731 mutex_lock(&acpi_link_lock);
732 result = acpi_pci_link_get_possible(link);
733 if (result)
734 goto end;
736 /* query and set link->irq.active */
737 acpi_pci_link_get_current(link);
739 printk(PREFIX "%s [%s] (IRQs", acpi_device_name(device),
740 acpi_device_bid(device));
741 for (i = 0; i < link->irq.possible_count; i++) {
742 if (link->irq.active == link->irq.possible[i]) {
743 printk(" *%d", link->irq.possible[i]);
744 found = 1;
745 } else
746 printk(" %d", link->irq.possible[i]);
747 }
749 printk(")");
751 if (!found)
752 printk(" *%d", link->irq.active);
754 if (!link->device->status.enabled)
755 printk(", disabled.");
757 printk("\n");
759 /* TBD: Acquire/release lock */
760 list_add_tail(&link->node, &acpi_link.entries);
761 acpi_link.count++;
763 end:
764 /* disable all links -- to be activated on use */
765 acpi_ut_evaluate_object(device->handle, "_DIS", 0, NULL);
766 mutex_unlock(&acpi_link_lock);
768 if (result)
769 kfree(link);
771 return result;
772 }
774 static int acpi_pci_link_resume(struct acpi_pci_link *link)
775 {
777 if (link->refcnt && link->irq.active && link->irq.initialized)
778 return (acpi_pci_link_set(link, link->irq.active));
779 else
780 return 0;
781 }
783 static int irqrouter_resume(struct sys_device *dev)
784 {
785 struct list_head *node = NULL;
786 struct acpi_pci_link *link = NULL;
789 /* Make sure SCI is enabled again (Apple firmware bug?) */
790 acpi_set_register(ACPI_BITREG_SCI_ENABLE, 1, ACPI_MTX_DO_NOT_LOCK);
792 list_for_each(node, &acpi_link.entries) {
793 link = list_entry(node, struct acpi_pci_link, node);
794 if (!link) {
795 printk(KERN_ERR PREFIX "Invalid link context\n");
796 continue;
797 }
798 acpi_pci_link_resume(link);
799 }
800 return 0;
801 }
803 static int acpi_pci_link_remove(struct acpi_device *device, int type)
804 {
805 struct acpi_pci_link *link = NULL;
808 if (!device || !acpi_driver_data(device))
809 return -EINVAL;
811 link = (struct acpi_pci_link *)acpi_driver_data(device);
813 mutex_lock(&acpi_link_lock);
814 list_del(&link->node);
815 mutex_unlock(&acpi_link_lock);
817 kfree(link);
819 return 0;
820 }
822 /*
823 * modify acpi_irq_penalty[] from cmdline
824 */
825 static int __init acpi_irq_penalty_update(char *str, int used)
826 {
827 int i;
829 for (i = 0; i < 16; i++) {
830 int retval;
831 int irq;
833 retval = get_option(&str, &irq);
835 if (!retval)
836 break; /* no number found */
838 if (irq < 0)
839 continue;
841 if (irq >= ACPI_MAX_IRQS)
842 continue;
844 if (used)
845 acpi_irq_penalty[irq] += PIRQ_PENALTY_ISA_USED;
846 else
847 acpi_irq_penalty[irq] = PIRQ_PENALTY_PCI_AVAILABLE;
849 if (retval != 2) /* no next number */
850 break;
851 }
852 return 1;
853 }
855 /*
856 * We'd like PNP to call this routine for the
857 * single ISA_USED value for each legacy device.
858 * But instead it calls us with each POSSIBLE setting.
859 * There is no ISA_POSSIBLE weight, so we simply use
860 * the (small) PCI_USING penalty.
861 */
862 void acpi_penalize_isa_irq(int irq, int active)
863 {
864 if (active)
865 acpi_irq_penalty[irq] += PIRQ_PENALTY_ISA_USED;
866 else
867 acpi_irq_penalty[irq] += PIRQ_PENALTY_PCI_USING;
868 }
870 /*
871 * Over-ride default table to reserve additional IRQs for use by ISA
872 * e.g. acpi_irq_isa=5
873 * Useful for telling ACPI how not to interfere with your ISA sound card.
874 */
875 static int __init acpi_irq_isa(char *str)
876 {
877 return acpi_irq_penalty_update(str, 1);
878 }
880 __setup("acpi_irq_isa=", acpi_irq_isa);
882 /*
883 * Over-ride default table to free additional IRQs for use by PCI
884 * e.g. acpi_irq_pci=7,15
885 * Used for acpi_irq_balance to free up IRQs to reduce PCI IRQ sharing.
886 */
887 static int __init acpi_irq_pci(char *str)
888 {
889 return acpi_irq_penalty_update(str, 0);
890 }
892 __setup("acpi_irq_pci=", acpi_irq_pci);
894 static int __init acpi_irq_nobalance_set(char *str)
895 {
896 acpi_irq_balance = 0;
897 return 1;
898 }
900 __setup("acpi_irq_nobalance", acpi_irq_nobalance_set);
902 int __init acpi_irq_balance_set(char *str)
903 {
904 acpi_irq_balance = 1;
905 return 1;
906 }
908 __setup("acpi_irq_balance", acpi_irq_balance_set);
910 /* FIXME: we will remove this interface after all drivers call pci_disable_device */
911 static struct sysdev_class irqrouter_sysdev_class = {
912 set_kset_name("irqrouter"),
913 .resume = irqrouter_resume,
914 };
916 static struct sys_device device_irqrouter = {
917 .id = 0,
918 .cls = &irqrouter_sysdev_class,
919 };
921 static int __init irqrouter_init_sysfs(void)
922 {
923 int error;
926 if (acpi_disabled || acpi_noirq)
927 return 0;
929 error = sysdev_class_register(&irqrouter_sysdev_class);
930 if (!error)
931 error = sysdev_register(&device_irqrouter);
933 return error;
934 }
936 device_initcall(irqrouter_init_sysfs);
938 static int __init acpi_pci_link_init(void)
939 {
941 if (acpi_noirq)
942 return 0;
944 acpi_link.count = 0;
945 INIT_LIST_HEAD(&acpi_link.entries);
947 if (acpi_bus_register_driver(&acpi_pci_link_driver) < 0)
948 return -ENODEV;
950 return 0;
951 }
953 subsys_initcall(acpi_pci_link_init);