ACPI: sbs: remove dead code
[linux-3.10.git] / drivers / acpi / pci_link.c
index 520b28a..c9f526e 100644 (file)
 #include <linux/spinlock.h>
 #include <linux/pm.h>
 #include <linux/pci.h>
+#include <linux/mutex.h>
 
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 
-
 #define _COMPONENT             ACPI_PCI_COMPONENT
-ACPI_MODULE_NAME               ("pci_link")
-
+ACPI_MODULE_NAME("pci_link");
 #define ACPI_PCI_LINK_CLASS            "pci_irq_routing"
-#define ACPI_PCI_LINK_HID              "PNP0C0F"
-#define ACPI_PCI_LINK_DRIVER_NAME      "ACPI PCI Interrupt Link Driver"
 #define ACPI_PCI_LINK_DEVICE_NAME      "PCI Interrupt Link"
 #define ACPI_PCI_LINK_FILE_INFO                "info"
 #define ACPI_PCI_LINK_FILE_STATUS      "state"
-
 #define ACPI_PCI_LINK_MAX_POSSIBLE 16
+static int acpi_pci_link_add(struct acpi_device *device);
+static int acpi_pci_link_remove(struct acpi_device *device, int type);
 
-static int acpi_pci_link_add (struct acpi_device *device);
-static int acpi_pci_link_remove (struct acpi_device *device, int type);
+static struct acpi_device_id link_device_ids[] = {
+       {"PNP0C0F", 0},
+       {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, link_device_ids);
 
 static struct acpi_driver acpi_pci_link_driver = {
-       .name =         ACPI_PCI_LINK_DRIVER_NAME,
-       .class =        ACPI_PCI_LINK_CLASS,
-       .ids =          ACPI_PCI_LINK_HID,
-       .ops =          {
-                               .add =    acpi_pci_link_add,
-                               .remove = acpi_pci_link_remove,
-                       },
+       .name = "pci_link",
+       .class = ACPI_PCI_LINK_CLASS,
+       .ids = link_device_ids,
+       .ops = {
+               .add = acpi_pci_link_add,
+               .remove = acpi_pci_link_remove,
+               },
 };
 
+/*
+ * If a link is initialized, we never change its active and initialized
+ * later even the link is disable. Instead, we just repick the active irq
+ */
 struct acpi_pci_link_irq {
-       u8                      active;                 /* Current IRQ */
-       u8                      edge_level;             /* All IRQs */
-       u8                      active_high_low;        /* All IRQs */
-       u8                      initialized;
-       u8                      resource_type;
-       u8                      possible_count;
-       u8                      possible[ACPI_PCI_LINK_MAX_POSSIBLE];
+       u8 active;              /* Current IRQ */
+       u8 triggering;          /* All IRQs */
+       u8 polarity;    /* All IRQs */
+       u8 resource_type;
+       u8 possible_count;
+       u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
+       u8 initialized:1;
+       u8 reserved:7;
 };
 
 struct acpi_pci_link {
-       struct list_head        node;
-       struct acpi_device      *device;
-       acpi_handle             handle;
+       struct list_head node;
+       struct acpi_device *device;
        struct acpi_pci_link_irq irq;
+       int refcnt;
 };
 
 static struct {
-       int                     count;
-       struct list_head        entries;
-}                              acpi_link;
-
+       int count;
+       struct list_head entries;
+} acpi_link;
+DEFINE_MUTEX(acpi_link_lock);
 
 /* --------------------------------------------------------------------------
                             PCI Link Device Management
@@ -99,140 +105,138 @@ static struct {
  * set context (link) possible list from resource list
  */
 static acpi_status
-acpi_pci_link_check_possible (
-       struct acpi_resource    *resource,
-       void                    *context)
+acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
 {
-       struct acpi_pci_link    *link = (struct acpi_pci_link *) context;
-       u32                     i = 0;
-
-       ACPI_FUNCTION_TRACE("acpi_pci_link_check_possible");
-
-       switch (resource->id) {
-       case ACPI_RSTYPE_START_DPF:
-               return_ACPI_STATUS(AE_OK);
-       case ACPI_RSTYPE_IRQ:
-       {
-               struct acpi_resource_irq *p = &resource->data.irq;
-               if (!p || !p->number_of_interrupts) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Blank IRQ resource\n"));
-                       return_ACPI_STATUS(AE_OK);
-               }
-               for (i = 0; (i<p->number_of_interrupts && i<ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
-                       if (!p->interrupts[i]) {
-                               ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ %d\n", p->interrupts[i]));
-                               continue;
+       struct acpi_pci_link *link = context;
+       u32 i = 0;
+
+
+       switch (resource->type) {
+       case ACPI_RESOURCE_TYPE_START_DEPENDENT:
+               return AE_OK;
+       case ACPI_RESOURCE_TYPE_IRQ:
+               {
+                       struct acpi_resource_irq *p = &resource->data.irq;
+                       if (!p || !p->interrupt_count) {
+                               printk(KERN_WARNING PREFIX "Blank IRQ resource\n");
+                               return AE_OK;
                        }
-                       link->irq.possible[i] = p->interrupts[i];
-                       link->irq.possible_count++;
-               }
-               link->irq.edge_level = p->edge_level;
-               link->irq.active_high_low = p->active_high_low;
-               link->irq.resource_type = ACPI_RSTYPE_IRQ;
-               break;
-       }
-       case ACPI_RSTYPE_EXT_IRQ:
-       {
-               struct acpi_resource_ext_irq *p = &resource->data.extended_irq;
-               if (!p || !p->number_of_interrupts) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_WARN, 
-                               "Blank EXT IRQ resource\n"));
-                       return_ACPI_STATUS(AE_OK);
+                       for (i = 0;
+                            (i < p->interrupt_count
+                             && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
+                               if (!p->interrupts[i]) {
+                                       printk(KERN_WARNING PREFIX "Invalid IRQ %d\n",
+                                                     p->interrupts[i]);
+                                       continue;
+                               }
+                               link->irq.possible[i] = p->interrupts[i];
+                               link->irq.possible_count++;
+                       }
+                       link->irq.triggering = p->triggering;
+                       link->irq.polarity = p->polarity;
+                       link->irq.resource_type = ACPI_RESOURCE_TYPE_IRQ;
+                       break;
                }
-               for (i = 0; (i<p->number_of_interrupts && i<ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
-                       if (!p->interrupts[i]) {
-                               ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ %d\n", p->interrupts[i]));
-                               continue;
+       case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+               {
+                       struct acpi_resource_extended_irq *p =
+                           &resource->data.extended_irq;
+                       if (!p || !p->interrupt_count) {
+                               printk(KERN_WARNING PREFIX
+                                             "Blank EXT IRQ resource\n");
+                               return AE_OK;
                        }
-                       link->irq.possible[i] = p->interrupts[i];
-                       link->irq.possible_count++;
+                       for (i = 0;
+                            (i < p->interrupt_count
+                             && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
+                               if (!p->interrupts[i]) {
+                                       printk(KERN_WARNING PREFIX "Invalid IRQ %d\n",
+                                                     p->interrupts[i]);
+                                       continue;
+                               }
+                               link->irq.possible[i] = p->interrupts[i];
+                               link->irq.possible_count++;
+                       }
+                       link->irq.triggering = p->triggering;
+                       link->irq.polarity = p->polarity;
+                       link->irq.resource_type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
+                       break;
                }
-               link->irq.edge_level = p->edge_level;
-               link->irq.active_high_low = p->active_high_low;
-               link->irq.resource_type = ACPI_RSTYPE_EXT_IRQ;
-               break;
-       }
        default:
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 
-                       "Resource is not an IRQ entry\n"));
-               return_ACPI_STATUS(AE_OK);
+               printk(KERN_ERR PREFIX "Resource is not an IRQ entry\n");
+               return AE_OK;
        }
 
-       return_ACPI_STATUS(AE_CTRL_TERMINATE);
+       return AE_CTRL_TERMINATE;
 }
 
-
-static int
-acpi_pci_link_get_possible (
-       struct acpi_pci_link    *link)
+static int acpi_pci_link_get_possible(struct acpi_pci_link *link)
 {
-       acpi_status             status;
+       acpi_status status;
 
-       ACPI_FUNCTION_TRACE("acpi_pci_link_get_possible");
 
        if (!link)
-               return_VALUE(-EINVAL);
+               return -EINVAL;
 
-       status = acpi_walk_resources(link->handle, METHOD_NAME__PRS,
-                       acpi_pci_link_check_possible, link);
+       status = acpi_walk_resources(link->device->handle, METHOD_NAME__PRS,
+                                    acpi_pci_link_check_possible, link);
        if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRS\n"));
-               return_VALUE(-ENODEV);
+               ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRS"));
+               return -ENODEV;
        }
 
-       ACPI_DEBUG_PRINT((ACPI_DB_INFO, 
-               "Found %d possible IRQs\n", link->irq.possible_count));
+       ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                         "Found %d possible IRQs\n",
+                         link->irq.possible_count));
 
-       return_VALUE(0);
+       return 0;
 }
 
-
 static acpi_status
-acpi_pci_link_check_current (
-       struct acpi_resource    *resource,
-       void                    *context)
+acpi_pci_link_check_current(struct acpi_resource *resource, void *context)
 {
-       int                     *irq = (int *) context;
-
-       ACPI_FUNCTION_TRACE("acpi_pci_link_check_current");
-
-       switch (resource->id) {
-       case ACPI_RSTYPE_IRQ:
-       {
-               struct acpi_resource_irq *p = &resource->data.irq;
-               if (!p || !p->number_of_interrupts) {
-                       /*
-                        * IRQ descriptors may have no IRQ# bits set,
-                        * particularly those those w/ _STA disabled
-                        */
-                       ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                               "Blank IRQ resource\n")); 
-                       return_ACPI_STATUS(AE_OK);
+       int *irq = (int *)context;
+
+
+       switch (resource->type) {
+       case ACPI_RESOURCE_TYPE_IRQ:
+               {
+                       struct acpi_resource_irq *p = &resource->data.irq;
+                       if (!p || !p->interrupt_count) {
+                               /*
+                                * IRQ descriptors may have no IRQ# bits set,
+                                * particularly those those w/ _STA disabled
+                                */
+                               ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                                 "Blank IRQ resource\n"));
+                               return AE_OK;
+                       }
+                       *irq = p->interrupts[0];
+                       break;
                }
-               *irq = p->interrupts[0];
-               break;
-       }
-       case ACPI_RSTYPE_EXT_IRQ:
-       {
-               struct acpi_resource_ext_irq *p = &resource->data.extended_irq;
-               if (!p || !p->number_of_interrupts) {
-                       /*
-                        * extended IRQ descriptors must
-                        * return at least 1 IRQ
-                        */
-                       ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                               "Blank EXT IRQ resource\n"));
-                       return_ACPI_STATUS(AE_OK);
+       case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+               {
+                       struct acpi_resource_extended_irq *p =
+                           &resource->data.extended_irq;
+                       if (!p || !p->interrupt_count) {
+                               /*
+                                * extended IRQ descriptors must
+                                * return at least 1 IRQ
+                                */
+                               printk(KERN_WARNING PREFIX
+                                             "Blank EXT IRQ resource\n");
+                               return AE_OK;
+                       }
+                       *irq = p->interrupts[0];
+                       break;
                }
-               *irq = p->interrupts[0];
                break;
-       }
        default:
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                       "Resource isn't an IRQ\n"));
-               return_ACPI_STATUS(AE_OK);
+               printk(KERN_ERR PREFIX "Resource %d isn't an IRQ\n", resource->type);
+       case ACPI_RESOURCE_TYPE_END_TAG:
+               return AE_OK;
        }
-       return_ACPI_STATUS(AE_CTRL_TERMINATE);
+       return AE_CTRL_TERMINATE;
 }
 
 /*
@@ -242,18 +246,14 @@ acpi_pci_link_check_current (
  * 0 - success
  * !0 - failure
  */
-static int
-acpi_pci_link_get_current (
-       struct acpi_pci_link    *link)
+static int acpi_pci_link_get_current(struct acpi_pci_link *link)
 {
-       int                     result = 0;
-       acpi_status             status = AE_OK;
-       int                     irq = 0;
-
-       ACPI_FUNCTION_TRACE("acpi_pci_link_get_current");
+       int result = 0;
+       acpi_status status = AE_OK;
+       int irq = 0;
 
-       if (!link || !link->handle)
-               return_VALUE(-EINVAL);
+       if (!link)
+               return -EINVAL;
 
        link->irq.active = 0;
 
@@ -262,13 +262,13 @@ acpi_pci_link_get_current (
                /* Query _STA, set link->device->status */
                result = acpi_bus_get_status(link->device);
                if (result) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to read status\n"));
+                       printk(KERN_ERR PREFIX "Unable to read status\n");
                        goto end;
                }
 
                if (!link->device->status.enabled) {
                        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link disabled\n"));
-                       return_VALUE(0);
+                       return 0;
                }
        }
 
@@ -276,16 +276,16 @@ acpi_pci_link_get_current (
         * Query and parse _CRS to get the current IRQ assignment. 
         */
 
-       status = acpi_walk_resources(link->handle, METHOD_NAME__CRS,
-                       acpi_pci_link_check_current, &irq);
+       status = acpi_walk_resources(link->device->handle, METHOD_NAME__CRS,
+                                    acpi_pci_link_check_current, &irq);
        if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _CRS\n"));
+               ACPI_EXCEPTION((AE_INFO, status, "Evaluating _CRS"));
                result = -ENODEV;
                goto end;
        }
 
        if (acpi_strict && !irq) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "_CRS returned 0\n"));
+               printk(KERN_ERR PREFIX "_CRS returned 0\n");
                result = -ENODEV;
        }
 
@@ -293,78 +293,79 @@ acpi_pci_link_get_current (
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link at IRQ %d \n", link->irq.active));
 
-end:
-       return_VALUE(result);
+      end:
+       return result;
 }
 
-static int
-acpi_pci_link_set (
-       struct acpi_pci_link    *link,
-       int                     irq)
+static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
 {
-       int                     result = 0;
-       acpi_status             status = AE_OK;
+       int result = 0;
+       acpi_status status = AE_OK;
        struct {
-               struct acpi_resource    res;
-               struct acpi_resource    end;
-       }    *resource;
-       struct acpi_buffer      buffer = {0, NULL};
+               struct acpi_resource res;
+               struct acpi_resource end;
+       } *resource;
+       struct acpi_buffer buffer = { 0, NULL };
 
-       ACPI_FUNCTION_TRACE("acpi_pci_link_set");
 
        if (!link || !irq)
-               return_VALUE(-EINVAL);
+               return -EINVAL;
 
-       resource = kmalloc( sizeof(*resource)+1, GFP_KERNEL);
-       if(!resource)
-               return_VALUE(-ENOMEM);
+       resource = kzalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
+       if (!resource)
+               return -ENOMEM;
 
-       memset(resource, 0, sizeof(*resource)+1);
-       buffer.length = sizeof(*resource) +1;
+       buffer.length = sizeof(*resource) + 1;
        buffer.pointer = resource;
 
-       switch(link->irq.resource_type) {
-       case ACPI_RSTYPE_IRQ:
-               resource->res.id = ACPI_RSTYPE_IRQ;
+       switch (link->irq.resource_type) {
+       case ACPI_RESOURCE_TYPE_IRQ:
+               resource->res.type = ACPI_RESOURCE_TYPE_IRQ;
                resource->res.length = sizeof(struct acpi_resource);
-               resource->res.data.irq.edge_level = link->irq.edge_level;
-               resource->res.data.irq.active_high_low = link->irq.active_high_low;
-               if (link->irq.edge_level == ACPI_EDGE_SENSITIVE)
-                       resource->res.data.irq.shared_exclusive = ACPI_EXCLUSIVE;
+               resource->res.data.irq.triggering = link->irq.triggering;
+               resource->res.data.irq.polarity =
+                   link->irq.polarity;
+               if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
+                       resource->res.data.irq.sharable =
+                           ACPI_EXCLUSIVE;
                else
-                       resource->res.data.irq.shared_exclusive = ACPI_SHARED;
-               resource->res.data.irq.number_of_interrupts = 1;
+                       resource->res.data.irq.sharable = ACPI_SHARED;
+               resource->res.data.irq.interrupt_count = 1;
                resource->res.data.irq.interrupts[0] = irq;
                break;
-          
-       case ACPI_RSTYPE_EXT_IRQ:
-               resource->res.id = ACPI_RSTYPE_EXT_IRQ;
+
+       case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+               resource->res.type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
                resource->res.length = sizeof(struct acpi_resource);
-               resource->res.data.extended_irq.producer_consumer = ACPI_CONSUMER;
-               resource->res.data.extended_irq.edge_level = link->irq.edge_level;
-               resource->res.data.extended_irq.active_high_low = link->irq.active_high_low;
-               if (link->irq.edge_level == ACPI_EDGE_SENSITIVE)
-                       resource->res.data.irq.shared_exclusive = ACPI_EXCLUSIVE;
+               resource->res.data.extended_irq.producer_consumer =
+                   ACPI_CONSUMER;
+               resource->res.data.extended_irq.triggering =
+                   link->irq.triggering;
+               resource->res.data.extended_irq.polarity =
+                   link->irq.polarity;
+               if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
+                       resource->res.data.irq.sharable =
+                           ACPI_EXCLUSIVE;
                else
-                       resource->res.data.irq.shared_exclusive = ACPI_SHARED;
-               resource->res.data.extended_irq.number_of_interrupts = 1;
+                       resource->res.data.irq.sharable = ACPI_SHARED;
+               resource->res.data.extended_irq.interrupt_count = 1;
                resource->res.data.extended_irq.interrupts[0] = irq;
                /* ignore resource_source, it's optional */
                break;
        default:
-               printk("ACPI BUG: resource_type %d\n", link->irq.resource_type);
+               printk(KERN_ERR PREFIX "Invalid Resource_type %d\n", link->irq.resource_type);
                result = -EINVAL;
                goto end;
 
        }
-       resource->end.id = ACPI_RSTYPE_END_TAG;
+       resource->end.type = ACPI_RESOURCE_TYPE_END_TAG;
 
        /* Attempt to set the resource */
-       status = acpi_set_current_resources(link->handle, &buffer);
+       status = acpi_set_current_resources(link->device->handle, &buffer);
 
        /* check for total failure */
        if (ACPI_FAILURE(status)) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _SRS\n"));
+               ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SRS"));
                result = -ENODEV;
                goto end;
        }
@@ -372,14 +373,14 @@ acpi_pci_link_set (
        /* Query _STA, set device->status */
        result = acpi_bus_get_status(link->device);
        if (result) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to read status\n"));
+               printk(KERN_ERR PREFIX "Unable to read status\n");
                goto end;
        }
        if (!link->device->status.enabled) {
                printk(KERN_WARNING PREFIX
-                       "%s [%s] disabled and referenced, BIOS bug.\n",
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device));
+                             "%s [%s] disabled and referenced, BIOS bug\n",
+                             acpi_device_name(link->device),
+                             acpi_device_bid(link->device));
        }
 
        /* Query _CRS, set link->irq.active */
@@ -397,22 +398,20 @@ acpi_pci_link_set (
                 * policy: when _CRS doesn't return what we just _SRS
                 * assume _SRS worked and override _CRS value.
                 */
-               printk(KERN_WARNING PREFIX 
-                       "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device),
-                       link->irq.active, irq);
+               printk(KERN_WARNING PREFIX
+                             "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
+                             acpi_device_name(link->device),
+                             acpi_device_bid(link->device), link->irq.active, irq);
                link->irq.active = irq;
        }
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Set IRQ %d\n", link->irq.active));
-       
-end:
+
+      end:
        kfree(resource);
-       return_VALUE(result);
+       return result;
 }
 
-
 /* --------------------------------------------------------------------------
                             PCI Link IRQ Management
    -------------------------------------------------------------------------- */
@@ -462,8 +461,8 @@ static int acpi_irq_penalty[ACPI_MAX_IRQS] = {
        PIRQ_PENALTY_ISA_ALWAYS,        /* IRQ0 timer */
        PIRQ_PENALTY_ISA_ALWAYS,        /* IRQ1 keyboard */
        PIRQ_PENALTY_ISA_ALWAYS,        /* IRQ2 cascade */
-       PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ3 serial */
-       PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ4 serial */
+       PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ3 serial */
+       PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ4 serial */
        PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ5 sometimes SoundBlaster */
        PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ6 */
        PIRQ_PENALTY_ISA_TYPICAL,       /* IRQ7 parallel, spurious */
@@ -475,17 +474,15 @@ static int acpi_irq_penalty[ACPI_MAX_IRQS] = {
        PIRQ_PENALTY_ISA_USED,  /* IRQ13 fpe, sometimes */
        PIRQ_PENALTY_ISA_USED,  /* IRQ14 ide0 */
        PIRQ_PENALTY_ISA_USED,  /* IRQ15 ide1 */
-                       /* >IRQ15 */
+       /* >IRQ15 */
 };
 
-int __init
-acpi_irq_penalty_init(void)
+int __init acpi_irq_penalty_init(void)
 {
-       struct list_head        *node = NULL;
-       struct acpi_pci_link    *link = NULL;
-       int                     i = 0;
+       struct list_head *node = NULL;
+       struct acpi_pci_link *link = NULL;
+       int i = 0;
 
-       ACPI_FUNCTION_TRACE("acpi_irq_penalty_init");
 
        /*
         * Update penalties to facilitate IRQ balancing.
@@ -494,7 +491,7 @@ acpi_irq_penalty_init(void)
 
                link = list_entry(node, struct acpi_pci_link, node);
                if (!link) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
+                       printk(KERN_ERR PREFIX "Invalid link context\n");
                        continue;
                }
 
@@ -503,35 +500,42 @@ acpi_irq_penalty_init(void)
                 * useful for breaking ties.
                 */
                if (link->irq.possible_count) {
-                       int penalty = PIRQ_PENALTY_PCI_POSSIBLE / link->irq.possible_count;
+                       int penalty =
+                           PIRQ_PENALTY_PCI_POSSIBLE /
+                           link->irq.possible_count;
 
                        for (i = 0; i < link->irq.possible_count; i++) {
                                if (link->irq.possible[i] < ACPI_MAX_ISA_IRQ)
-                                       acpi_irq_penalty[link->irq.possible[i]] += penalty;
+                                       acpi_irq_penalty[link->irq.
+                                                        possible[i]] +=
+                                           penalty;
                        }
 
                } else if (link->irq.active) {
-                       acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_POSSIBLE;
+                       acpi_irq_penalty[link->irq.active] +=
+                           PIRQ_PENALTY_PCI_POSSIBLE;
                }
        }
        /* Add a penalty for the SCI */
-       acpi_irq_penalty[acpi_fadt.sci_int] += PIRQ_PENALTY_PCI_USING;
+       acpi_irq_penalty[acpi_gbl_FADT.sci_interrupt] += PIRQ_PENALTY_PCI_USING;
 
-       return_VALUE(0);
+       return 0;
 }
 
 static int acpi_irq_balance;   /* 0: static, 1: balance */
 
-static int acpi_pci_link_allocate(
-       struct acpi_pci_link    *link)
+static int acpi_pci_link_allocate(struct acpi_pci_link *link)
 {
-       int                     irq;
-       int                     i;
+       int irq;
+       int i;
 
-       ACPI_FUNCTION_TRACE("acpi_pci_link_allocate");
 
-       if (link->irq.initialized)
-               return_VALUE(0);
+       if (link->irq.initialized) {
+               if (link->refcnt == 0)
+                       /* This means the link is disabled but initialized */
+                       acpi_pci_link_set(link, link->irq.active);
+               return 0;
+       }
 
        /*
         * search for active IRQ in list of possible IRQs.
@@ -546,7 +550,7 @@ static int acpi_pci_link_allocate(
        if (i == link->irq.possible_count) {
                if (acpi_strict)
                        printk(KERN_WARNING PREFIX "_CRS %d not found"
-                               " in _PRS\n", link->irq.active);
+                                     " in _PRS\n", link->irq.active);
                link->irq.active = 0;
        }
 
@@ -565,112 +569,168 @@ static int acpi_pci_link_allocate(
                 * the use of IRQs 9, 10, 11, and >15.
                 */
                for (i = (link->irq.possible_count - 1); i >= 0; i--) {
-                       if (acpi_irq_penalty[irq] > acpi_irq_penalty[link->irq.possible[i]])
+                       if (acpi_irq_penalty[irq] >
+                           acpi_irq_penalty[link->irq.possible[i]])
                                irq = link->irq.possible[i];
                }
        }
 
        /* Attempt to enable the link device at this IRQ. */
        if (acpi_pci_link_set(link, irq)) {
-               printk(PREFIX "Unable to set IRQ for %s [%s] (likely buggy ACPI BIOS).\n"
-                               "Try pci=noacpi or acpi=off\n",
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device));
-               return_VALUE(-ENODEV);
+               printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. "
+                           "Try pci=noacpi or acpi=off\n",
+                           acpi_device_name(link->device),
+                           acpi_device_bid(link->device));
+               return -ENODEV;
        } else {
                acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_USING;
-               printk(PREFIX "%s [%s] enabled at IRQ %d\n", 
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device), link->irq.active);
+               printk(PREFIX "%s [%s] enabled at IRQ %d\n",
+                      acpi_device_name(link->device),
+                      acpi_device_bid(link->device), link->irq.active);
        }
 
        link->irq.initialized = 1;
 
-       return_VALUE(0);
+       return 0;
 }
 
 /*
- * acpi_pci_link_get_irq
+ * acpi_pci_link_allocate_irq
  * success: return IRQ >= 0
  * failure: return -1
  */
 
 int
-acpi_pci_link_get_irq (
-       acpi_handle             handle,
-       int                     index,
-       int                     *edge_level,
-       int                     *active_high_low,
-       char                    **name)
+acpi_pci_link_allocate_irq(acpi_handle handle,
+                          int index,
+                          int *triggering, int *polarity, char **name)
 {
-       int                     result = 0;
-       struct acpi_device      *device = NULL;
-       struct acpi_pci_link    *link = NULL;
+       int result = 0;
+       struct acpi_device *device = NULL;
+       struct acpi_pci_link *link = NULL;
 
-       ACPI_FUNCTION_TRACE("acpi_pci_link_get_irq");
 
        result = acpi_bus_get_device(handle, &device);
        if (result) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link device\n"));
-               return_VALUE(-1);
+               printk(KERN_ERR PREFIX "Invalid link device\n");
+               return -1;
        }
 
-       link = (struct acpi_pci_link *) acpi_driver_data(device);
+       link = acpi_driver_data(device);
        if (!link) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
-               return_VALUE(-1);
+               printk(KERN_ERR PREFIX "Invalid link context\n");
+               return -1;
        }
 
        /* TBD: Support multiple index (IRQ) entries per Link Device */
        if (index) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid index %d\n", index));
-               return_VALUE(-1);
+               printk(KERN_ERR PREFIX "Invalid index %d\n", index);
+               return -1;
        }
 
-       if (acpi_pci_link_allocate(link))
-               return_VALUE(-1);
-          
-       if (!link->irq.active) {
-               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n"));
-               return_VALUE(-1);
+       mutex_lock(&acpi_link_lock);
+       if (acpi_pci_link_allocate(link)) {
+               mutex_unlock(&acpi_link_lock);
+               return -1;
        }
 
-       if (edge_level) *edge_level = link->irq.edge_level;
-       if (active_high_low) *active_high_low = link->irq.active_high_low;
-       if (name) *name = acpi_device_bid(link->device);
-       return_VALUE(link->irq.active);
+       if (!link->irq.active) {
+               mutex_unlock(&acpi_link_lock);
+               printk(KERN_ERR PREFIX "Link active IRQ is 0!\n");
+               return -1;
+       }
+       link->refcnt++;
+       mutex_unlock(&acpi_link_lock);
+
+       if (triggering)
+               *triggering = link->irq.triggering;
+       if (polarity)
+               *polarity = link->irq.polarity;
+       if (name)
+               *name = acpi_device_bid(link->device);
+       ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                         "Link %s is referenced\n",
+                         acpi_device_bid(link->device)));
+       return (link->irq.active);
 }
 
+/*
+ * We don't change link's irq information here.  After it is reenabled, we
+ * continue use the info
+ */
+int acpi_pci_link_free_irq(acpi_handle handle)
+{
+       struct acpi_device *device = NULL;
+       struct acpi_pci_link *link = NULL;
+       acpi_status result;
+
+
+       result = acpi_bus_get_device(handle, &device);
+       if (result) {
+               printk(KERN_ERR PREFIX "Invalid link device\n");
+               return -1;
+       }
+
+       link = acpi_driver_data(device);
+       if (!link) {
+               printk(KERN_ERR PREFIX "Invalid link context\n");
+               return -1;
+       }
+
+       mutex_lock(&acpi_link_lock);
+       if (!link->irq.initialized) {
+               mutex_unlock(&acpi_link_lock);
+               printk(KERN_ERR PREFIX "Link isn't initialized\n");
+               return -1;
+       }
+#ifdef FUTURE_USE
+       /*
+        * The Link reference count allows us to _DISable an unused link
+        * and suspend time, and set it again  on resume.
+        * However, 2.6.12 still has irq_router.resume
+        * which blindly restores the link state.
+        * So we disable the reference count method
+        * to prevent duplicate acpi_pci_link_set()
+        * which would harm some systems
+        */
+       link->refcnt--;
+#endif
+       ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                         "Link %s is dereferenced\n",
+                         acpi_device_bid(link->device)));
+
+       if (link->refcnt == 0) {
+               acpi_ut_evaluate_object(link->device->handle, "_DIS", 0, NULL);
+       }
+       mutex_unlock(&acpi_link_lock);
+       return (link->irq.active);
+}
 
 /* --------------------------------------------------------------------------
                                  Driver Interface
    -------------------------------------------------------------------------- */
 
-static int
-acpi_pci_link_add (
-       struct acpi_device *device)
+static int acpi_pci_link_add(struct acpi_device *device)
 {
-       int                     result = 0;
-       struct acpi_pci_link    *link = NULL;
-       int                     i = 0;
-       int                     found = 0;
+       int result = 0;
+       struct acpi_pci_link *link = NULL;
+       int i = 0;
+       int found = 0;
 
-       ACPI_FUNCTION_TRACE("acpi_pci_link_add");
 
        if (!device)
-               return_VALUE(-EINVAL);
+               return -EINVAL;
 
-       link = kmalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
+       link = kzalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
        if (!link)
-               return_VALUE(-ENOMEM);
-       memset(link, 0, sizeof(struct acpi_pci_link));
+               return -ENOMEM;
 
        link->device = device;
-       link->handle = device->handle;
        strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
        strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
        acpi_driver_data(device) = link;
 
+       mutex_lock(&acpi_link_lock);
        result = acpi_pci_link_get_possible(link);
        if (result)
                goto end;
@@ -678,14 +738,13 @@ acpi_pci_link_add (
        /* query and set link->irq.active */
        acpi_pci_link_get_current(link);
 
-       printk(PREFIX "%s [%s] (IRQs", acpi_device_name(device),
-               acpi_device_bid(device));
+       printk(KERN_INFO PREFIX "%s [%s] (IRQs", acpi_device_name(device),
+              acpi_device_bid(device));
        for (i = 0; i < link->irq.possible_count; i++) {
                if (link->irq.active == link->irq.possible[i]) {
                        printk(" *%d", link->irq.possible[i]);
                        found = 1;
-               }
-               else
+               } else
                        printk(" %d", link->irq.possible[i]);
        }
 
@@ -694,7 +753,7 @@ acpi_pci_link_add (
        if (!found)
                printk(" *%d", link->irq.active);
 
-       if(!link->device->status.enabled)
+       if (!link->device->status.enabled)
                printk(", disabled.");
 
        printk("\n");
@@ -703,73 +762,63 @@ acpi_pci_link_add (
        list_add_tail(&link->node, &acpi_link.entries);
        acpi_link.count++;
 
-end:
+      end:
        /* disable all links -- to be activated on use */
-       acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
+       acpi_ut_evaluate_object(device->handle, "_DIS", 0, NULL);
+       mutex_unlock(&acpi_link_lock);
 
        if (result)
                kfree(link);
 
-       return_VALUE(result);
+       return result;
 }
 
-
-static int
-acpi_pci_link_resume (
-       struct acpi_pci_link    *link)
+static int acpi_pci_link_resume(struct acpi_pci_link *link)
 {
-       ACPI_FUNCTION_TRACE("acpi_pci_link_resume");
-       
-       if (link->irq.active && link->irq.initialized)
-               return_VALUE(acpi_pci_link_set(link, link->irq.active));
+
+       if (link->refcnt && link->irq.active && link->irq.initialized)
+               return (acpi_pci_link_set(link, link->irq.active));
        else
-               return_VALUE(0);
+               return 0;
 }
 
-
-static int
-irqrouter_resume(
-       struct sys_device *dev)
+static int irqrouter_resume(struct sys_device *dev)
 {
-       struct list_head        *node = NULL;
-       struct acpi_pci_link    *link = NULL;
+       struct list_head *node = NULL;
+       struct acpi_pci_link *link = NULL;
 
-       ACPI_FUNCTION_TRACE("irqrouter_resume");
 
-       list_for_each(node, &acpi_link.entries) {
+       /* Make sure SCI is enabled again (Apple firmware bug?) */
+       acpi_set_register(ACPI_BITREG_SCI_ENABLE, 1);
 
+       list_for_each(node, &acpi_link.entries) {
                link = list_entry(node, struct acpi_pci_link, node);
                if (!link) {
-                       ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
+                       printk(KERN_ERR PREFIX "Invalid link context\n");
                        continue;
                }
-
                acpi_pci_link_resume(link);
        }
-       return_VALUE(0);
+       return 0;
 }
 
-
-static int
-acpi_pci_link_remove (
-       struct acpi_device      *device,
-       int                     type)
+static int acpi_pci_link_remove(struct acpi_device *device, int type)
 {
        struct acpi_pci_link *link = NULL;
 
-       ACPI_FUNCTION_TRACE("acpi_pci_link_remove");
 
        if (!device || !acpi_driver_data(device))
-               return_VALUE(-EINVAL);
+               return -EINVAL;
 
-       link = (struct acpi_pci_link *) acpi_driver_data(device);
+       link = acpi_driver_data(device);
 
-       /* TBD: Acquire/release lock */
+       mutex_lock(&acpi_link_lock);
        list_del(&link->node);
+       mutex_unlock(&acpi_link_lock);
 
        kfree(link);
 
-       return_VALUE(0);
+       return 0;
 }
 
 /*
@@ -783,14 +832,14 @@ static int __init acpi_irq_penalty_update(char *str, int used)
                int retval;
                int irq;
 
-               retval = get_option(&str,&irq);
+               retval = get_option(&str, &irq);
 
                if (!retval)
                        break;  /* no number found */
 
                if (irq < 0)
                        continue;
-               
+
                if (irq >= ACPI_MAX_IRQS)
                        continue;
 
@@ -812,9 +861,12 @@ static int __init acpi_irq_penalty_update(char *str, int used)
  * There is no ISA_POSSIBLE weight, so we simply use
  * the (small) PCI_USING penalty.
  */
-void acpi_penalize_isa_irq(int irq)
+void acpi_penalize_isa_irq(int irq, int active)
 {
-       acpi_irq_penalty[irq] += PIRQ_PENALTY_PCI_USING;
+       if (active)
+               acpi_irq_penalty[irq] += PIRQ_PENALTY_ISA_USED;
+       else
+               acpi_irq_penalty[irq] += PIRQ_PENALTY_PCI_USING;
 }
 
 /*
@@ -826,6 +878,7 @@ static int __init acpi_irq_isa(char *str)
 {
        return acpi_irq_penalty_update(str, 1);
 }
+
 __setup("acpi_irq_isa=", acpi_irq_isa);
 
 /*
@@ -837,6 +890,7 @@ static int __init acpi_irq_pci(char *str)
 {
        return acpi_irq_penalty_update(str, 0);
 }
+
 __setup("acpi_irq_pci=", acpi_irq_pci);
 
 static int __init acpi_irq_nobalance_set(char *str)
@@ -844,6 +898,7 @@ static int __init acpi_irq_nobalance_set(char *str)
        acpi_irq_balance = 0;
        return 1;
 }
+
 __setup("acpi_irq_nobalance", acpi_irq_nobalance_set);
 
 int __init acpi_irq_balance_set(char *str)
@@ -851,54 +906,50 @@ int __init acpi_irq_balance_set(char *str)
        acpi_irq_balance = 1;
        return 1;
 }
-__setup("acpi_irq_balance", acpi_irq_balance_set);
 
+__setup("acpi_irq_balance", acpi_irq_balance_set);
 
+/* FIXME: we will remove this interface after all drivers call pci_disable_device */
 static struct sysdev_class irqrouter_sysdev_class = {
-        set_kset_name("irqrouter"),
-        .resume = irqrouter_resume,
+       set_kset_name("irqrouter"),
+       .resume = irqrouter_resume,
 };
 
-
 static struct sys_device device_irqrouter = {
-       .id     = 0,
-       .cls    = &irqrouter_sysdev_class,
+       .id = 0,
+       .cls = &irqrouter_sysdev_class,
 };
 
-
 static int __init irqrouter_init_sysfs(void)
 {
        int error;
 
-       ACPI_FUNCTION_TRACE("irqrouter_init_sysfs");
 
        if (acpi_disabled || acpi_noirq)
-               return_VALUE(0);
+               return 0;
 
        error = sysdev_class_register(&irqrouter_sysdev_class);
        if (!error)
                error = sysdev_register(&device_irqrouter);
 
-       return_VALUE(error);
-}                                        
+       return error;
+}
 
 device_initcall(irqrouter_init_sysfs);
 
-
-static int __init acpi_pci_link_init (void)
+static int __init acpi_pci_link_init(void)
 {
-       ACPI_FUNCTION_TRACE("acpi_pci_link_init");
 
        if (acpi_noirq)
-               return_VALUE(0);
+               return 0;
 
        acpi_link.count = 0;
        INIT_LIST_HEAD(&acpi_link.entries);
 
        if (acpi_bus_register_driver(&acpi_pci_link_driver) < 0)
-               return_VALUE(-ENODEV);
+               return -ENODEV;
 
-       return_VALUE(0);
+       return 0;
 }
 
 subsys_initcall(acpi_pci_link_init);