#include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 
-#define _COMPONENT             ACPI_PCI_COMPONENT
+#define _COMPONENT                     ACPI_PCI_COMPONENT
 ACPI_MODULE_NAME("pci_link");
 #define ACPI_PCI_LINK_CLASS            "pci_irq_routing"
 #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
+#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);
 
        .ops = {
                .add = acpi_pci_link_add,
                .remove = acpi_pci_link_remove,
-               },
+       },
 };
 
 /*
 struct acpi_pci_link_irq {
        u8 active;              /* Current IRQ */
        u8 triggering;          /* All IRQs */
-       u8 polarity;    /* All IRQs */
+       u8 polarity;            /* All IRQs */
        u8 resource_type;
        u8 possible_count;
        u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
 };
 
 struct acpi_pci_link {
-       struct list_head node;
-       struct acpi_device *device;
-       struct acpi_pci_link_irq irq;
-       int refcnt;
+       struct list_head                node;
+       struct acpi_device              *device;
+       struct acpi_pci_link_irq        irq;
+       int                             refcnt;
 };
 
 static struct {
-       int count;
-       struct list_head entries;
+       int                     count;
+       struct list_head        entries;
 } acpi_link;
 static DEFINE_MUTEX(acpi_link_lock);
 
 /*
  * set context (link) possible list from resource list
  */
-static acpi_status
-acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
+static acpi_status acpi_pci_link_check_possible(struct acpi_resource *resource,
+                                               void *context)
 {
        struct acpi_pci_link *link = context;
        u32 i = 0;
 
-
        switch (resource->type) {
        case ACPI_RESOURCE_TYPE_START_DEPENDENT:
        case ACPI_RESOURCE_TYPE_END_TAG:
 {
        acpi_status status;
 
-
        if (!link)
                return -EINVAL;
 
        return 0;
 }
 
-static acpi_status
-acpi_pci_link_check_current(struct acpi_resource *resource, void *context)
+static acpi_status acpi_pci_link_check_current(struct acpi_resource *resource,
+                                              void *context)
 {
        int *irq = (int *)context;
 
-
        switch (resource->type) {
        case ACPI_RESOURCE_TYPE_START_DEPENDENT:
        case ACPI_RESOURCE_TYPE_END_TAG:
        } *resource;
        struct acpi_buffer buffer = { 0, NULL };
 
-
        if (!link || !irq)
                return -EINVAL;
 
        PIRQ_PENALTY_PCI_AVAILABLE,     /* IRQ9  PCI, often acpi */
        PIRQ_PENALTY_PCI_AVAILABLE,     /* IRQ10 PCI */
        PIRQ_PENALTY_PCI_AVAILABLE,     /* IRQ11 PCI */
-       PIRQ_PENALTY_ISA_USED,  /* IRQ12 mouse */
-       PIRQ_PENALTY_ISA_USED,  /* IRQ13 fpe, sometimes */
-       PIRQ_PENALTY_ISA_USED,  /* IRQ14 ide0 */
-       PIRQ_PENALTY_ISA_USED,  /* IRQ15 ide1 */
+       PIRQ_PENALTY_ISA_USED,          /* IRQ12 mouse */
+       PIRQ_PENALTY_ISA_USED,          /* IRQ13 fpe, sometimes */
+       PIRQ_PENALTY_ISA_USED,          /* IRQ14 ide0 */
+       PIRQ_PENALTY_ISA_USED,          /* IRQ15 ide1 */
        /* >IRQ15 */
 };
 
        struct acpi_pci_link *link = NULL;
        int i = 0;
 
-
        /*
         * Update penalties to facilitate IRQ balancing.
         */
        list_for_each(node, &acpi_link.entries) {
-
                link = list_entry(node, struct acpi_pci_link, node);
                if (!link) {
                        printk(KERN_ERR PREFIX "Invalid link context\n");
        }
        /* Add a penalty for the SCI */
        acpi_irq_penalty[acpi_gbl_FADT.sci_interrupt] += PIRQ_PENALTY_PCI_USING;
-
        return 0;
 }
 
        int irq;
        int i;
 
-
        if (link->irq.initialized) {
                if (link->refcnt == 0)
                        /* This means the link is disabled but initialized */
        /*
         * if active found, use it; else pick entry from end of possible list.
         */
-       if (link->irq.active) {
+       if (link->irq.active)
                irq = link->irq.active;
-       } else {
+       else
                irq = link->irq.possible[link->irq.possible_count - 1];
-       }
 
        if (acpi_irq_balance || !link->irq.active) {
                /*
        }
 
        link->irq.initialized = 1;
-
        return 0;
 }
 
  * success: return IRQ >= 0
  * failure: return -1
  */
-
-int
-acpi_pci_link_allocate_irq(acpi_handle handle,
-                          int index,
-                          int *triggering, int *polarity, char **name)
+int 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;
 
-
        result = acpi_bus_get_device(handle, &device);
        if (result) {
                printk(KERN_ERR PREFIX "Invalid link device\n");
        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");
                          "Link %s is dereferenced\n",
                          acpi_device_bid(link->device)));
 
-       if (link->refcnt == 0) {
+       if (link->refcnt == 0)
                acpi_evaluate_object(link->device->handle, "_DIS", NULL, NULL);
-       }
+
        mutex_unlock(&acpi_link_lock);
        return (link->irq.active);
 }
        int i = 0;
        int found = 0;
 
-
        if (!device)
                return -EINVAL;
 
 
 static int acpi_pci_link_resume(struct acpi_pci_link *link)
 {
-
        if (link->refcnt && link->irq.active && link->irq.initialized)
                return (acpi_pci_link_set(link, link->irq.active));
-       else
-               return 0;
+
+       return 0;
 }
 
 static int irqrouter_resume(struct sys_device *dev)
 {
        struct acpi_pci_link *link = NULL;
 
-
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
 
        mutex_unlock(&acpi_link_lock);
 
        kfree(link);
-
        return 0;
 }
 
 {
        int error;
 
-
        if (acpi_disabled || acpi_noirq)
                return 0;