[ACPI] Lindent all ACPI files

Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 251 insertions, 316 deletions

diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index f3a807c342c0..9127760d36c5 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -45,16 +45,12 @@
 
 #include <linux/efi.h>
 
-
 #define _COMPONENT              ACPI_OS_SERVICES
-ACPI_MODULE_NAME        ("osl")
-
+ACPI_MODULE_NAME("osl")
 #define PREFIX          "ACPI: "
-
-struct acpi_os_dpc
-{
-    acpi_osd_exec_callback  function;
-    void                    *context;
+struct acpi_os_dpc {
+        acpi_osd_exec_callback function;
+        void *context;
 };
 
 #ifdef CONFIG_ACPI_CUSTOM_DSDT
@@ -69,7 +65,7 @@ int acpi_in_debugger;
 EXPORT_SYMBOL(acpi_in_debugger);
 
 extern char line_buf[80];
-#endif /*ENABLE_DEBUGGER*/
+#endif                          /*ENABLE_DEBUGGER */
 
 int acpi_specific_hotkey_enabled;
 EXPORT_SYMBOL(acpi_specific_hotkey_enabled);
@@ -79,14 +75,12 @@ static acpi_osd_handler acpi_irq_handler;
 static void *acpi_irq_context;
 static struct workqueue_struct *kacpid_wq;
 
-acpi_status
-acpi_os_initialize(void)
+acpi_status acpi_os_initialize(void)
 {
         return AE_OK;
 }
 
-acpi_status
-acpi_os_initialize1(void)
+acpi_status acpi_os_initialize1(void)
 {
         /*
          * Initialize PCI configuration space access, as we'll need to access
@@ -94,7 +88,8 @@ acpi_os_initialize1(void)
          */
 #ifdef CONFIG_ACPI_PCI
         if (!raw_pci_ops) {
-                printk(KERN_ERR PREFIX "Access to PCI configuration space unavailable\n");
+                printk(KERN_ERR PREFIX
+                       "Access to PCI configuration space unavailable\n");
                 return AE_NULL_ENTRY;
         }
 #endif
@@ -104,8 +99,7 @@ acpi_os_initialize1(void)
         return AE_OK;
 }
 
-acpi_status
-acpi_os_terminate(void)
+acpi_status acpi_os_terminate(void)
 {
         if (acpi_irq_handler) {
                 acpi_os_remove_interrupt_handler(acpi_irq_irq,
@@ -117,21 +111,20 @@ acpi_os_terminate(void)
         return AE_OK;
 }
 
-void
-acpi_os_printf(const char *fmt,...)
+void acpi_os_printf(const char *fmt, ...)
 {
         va_list args;
         va_start(args, fmt);
         acpi_os_vprintf(fmt, args);
         va_end(args);
 }
+
 EXPORT_SYMBOL(acpi_os_printf);
 
-void
-acpi_os_vprintf(const char *fmt, va_list args)
+void acpi_os_vprintf(const char *fmt, va_list args)
 {
         static char buffer[512];
-        
+
         vsprintf(buffer, fmt, args);
 
 #ifdef ENABLE_DEBUGGER
@@ -146,8 +139,7 @@ acpi_os_vprintf(const char *fmt, va_list args)
 }
 
 extern int acpi_in_resume;
-void *
-acpi_os_allocate(acpi_size size)
+void *acpi_os_allocate(acpi_size size)
 {
         if (acpi_in_resume)
                 return kmalloc(size, GFP_ATOMIC);
@@ -155,31 +147,32 @@ acpi_os_allocate(acpi_size size)
                 return kmalloc(size, GFP_KERNEL);
 }
 
-void
-acpi_os_free(void *ptr)
+void acpi_os_free(void *ptr)
 {
         kfree(ptr);
 }
+
 EXPORT_SYMBOL(acpi_os_free);
 
-acpi_status
-acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
+acpi_status acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
 {
         if (efi_enabled) {
                 addr->pointer_type = ACPI_PHYSICAL_POINTER;
                 if (efi.acpi20)
                         addr->pointer.physical =
-                                (acpi_physical_address) virt_to_phys(efi.acpi20);
+                            (acpi_physical_address) virt_to_phys(efi.acpi20);
                 else if (efi.acpi)
                         addr->pointer.physical =
-                                (acpi_physical_address) virt_to_phys(efi.acpi);
+                            (acpi_physical_address) virt_to_phys(efi.acpi);
                 else {
-                        printk(KERN_ERR PREFIX "System description tables not found\n");
+                        printk(KERN_ERR PREFIX
+                               "System description tables not found\n");
                         return AE_NOT_FOUND;
                 }
         } else {
                 if (ACPI_FAILURE(acpi_find_root_pointer(flags, addr))) {
-                        printk(KERN_ERR PREFIX "System description tables not found\n");
+                        printk(KERN_ERR PREFIX
+                               "System description tables not found\n");
                         return AE_NOT_FOUND;
                 }
         }
@@ -188,11 +181,12 @@ acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
 }
 
 acpi_status
-acpi_os_map_memory(acpi_physical_address phys, acpi_size size, void __iomem **virt)
+acpi_os_map_memory(acpi_physical_address phys, acpi_size size,
+                   void __iomem ** virt)
 {
         if (efi_enabled) {
                 if (EFI_MEMORY_WB & efi_mem_attributes(phys)) {
-                        *virt = (void __iomem *) phys_to_virt(phys);
+                        *virt = (void __iomem *)phys_to_virt(phys);
                 } else {
                         *virt = ioremap(phys, size);
                 }
@@ -202,9 +196,9 @@ acpi_os_map_memory(acpi_physical_address phys, acpi_size size, void __iomem **vi
                         return AE_BAD_PARAMETER;
                 }
                 /*
-                 * ioremap checks to ensure this is in reserved space
-                 */
-                *virt = ioremap((unsigned long) phys, size);
+                 * ioremap checks to ensure this is in reserved space
+                 */
+                *virt = ioremap((unsigned long)phys, size);
         }
 
         if (!*virt)
@@ -213,17 +207,16 @@ acpi_os_map_memory(acpi_physical_address phys, acpi_size size, void __iomem **vi
         return AE_OK;
 }
 
-void
-acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
+void acpi_os_unmap_memory(void __iomem * virt, acpi_size size)
 {
         iounmap(virt);
 }
 
 #ifdef ACPI_FUTURE_USAGE
 acpi_status
-acpi_os_get_physical_address(void *virt, acpi_physical_address *phys)
+acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
 {
-        if(!phys || !virt)
+        if (!phys || !virt)
                 return AE_BAD_PARAMETER;
 
         *phys = virt_to_phys(virt);
@@ -237,16 +230,16 @@ acpi_os_get_physical_address(void *virt, acpi_physical_address *phys)
 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
 
 acpi_status
-acpi_os_predefined_override (const struct acpi_predefined_names *init_val,
-                             acpi_string *new_val)
+acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
+                            acpi_string * new_val)
 {
         if (!init_val || !new_val)
                 return AE_BAD_PARAMETER;
 
         *new_val = NULL;
-        if (!memcmp (init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
+        if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
                 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
-                        acpi_os_name);
+                       acpi_os_name);
                 *new_val = acpi_os_name;
         }
 
@@ -254,15 +247,15 @@ acpi_os_predefined_override (const struct acpi_predefined_names *init_val,
 }
 
 acpi_status
-acpi_os_table_override (struct acpi_table_header *existing_table,
-                        struct acpi_table_header **new_table)
+acpi_os_table_override(struct acpi_table_header * existing_table,
+                       struct acpi_table_header ** new_table)
 {
         if (!existing_table || !new_table)
                 return AE_BAD_PARAMETER;
 
 #ifdef CONFIG_ACPI_CUSTOM_DSDT
         if (strncmp(existing_table->signature, "DSDT", 4) == 0)
-                *new_table = (struct acpi_table_header*)AmlCode;
+                *new_table = (struct acpi_table_header *)AmlCode;
         else
                 *new_table = NULL;
 #else
@@ -271,14 +264,14 @@ acpi_os_table_override (struct acpi_table_header *existing_table,
         return AE_OK;
 }
 
-static irqreturn_t
-acpi_irq(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t acpi_irq(int irq, void *dev_id, struct pt_regs *regs)
 {
-        return (*acpi_irq_handler)(acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
+        return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
 }
 
 acpi_status
-acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler, void *context)
+acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
+                                  void *context)
 {
         unsigned int irq;
 
@@ -305,8 +298,7 @@ acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler, void *conte
         return AE_OK;
 }
 
-acpi_status
-acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
+acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
 {
         if (irq) {
                 free_irq(irq, acpi_irq);
@@ -321,16 +313,15 @@ acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
  * Running in interpreter thread context, safe to sleep
  */
 
-void
-acpi_os_sleep(acpi_integer ms)
+void acpi_os_sleep(acpi_integer ms)
 {
         current->state = TASK_INTERRUPTIBLE;
-        schedule_timeout(((signed long) ms * HZ) / 1000);
+        schedule_timeout(((signed long)ms * HZ) / 1000);
 }
+
 EXPORT_SYMBOL(acpi_os_sleep);
 
-void
-acpi_os_stall(u32 us)
+void acpi_os_stall(u32 us)
 {
         while (us) {
                 u32 delay = 1000;
@@ -342,6 +333,7 @@ acpi_os_stall(u32 us)
                 us -= delay;
         }
 }
+
 EXPORT_SYMBOL(acpi_os_stall);
 
 /*
@@ -349,8 +341,7 @@ EXPORT_SYMBOL(acpi_os_stall);
  * Returns 64-bit free-running, monotonically increasing timer
  * with 100ns granularity
  */
-u64
-acpi_os_get_timer (void)
+u64 acpi_os_get_timer(void)
 {
         static u64 t;
 
@@ -367,27 +358,22 @@ acpi_os_get_timer (void)
         return ++t;
 }
 
-acpi_status
-acpi_os_read_port(
-        acpi_io_address port,
-        u32             *value,
-        u32             width)
+acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
 {
         u32 dummy;
 
         if (!value)
                 value = &dummy;
 
-        switch (width)
-        {
+        switch (width) {
         case 8:
-                *(u8*)  value = inb(port);
+                *(u8 *) value = inb(port);
                 break;
         case 16:
-                *(u16*) value = inw(port);
+                *(u16 *) value = inw(port);
                 break;
         case 32:
-                *(u32*) value = inl(port);
+                *(u32 *) value = inl(port);
                 break;
         default:
                 BUG();
@@ -395,16 +381,12 @@ acpi_os_read_port(
 
         return AE_OK;
 }
+
 EXPORT_SYMBOL(acpi_os_read_port);
 
-acpi_status
-acpi_os_write_port(
-        acpi_io_address port,
-        u32             value,
-        u32             width)
+acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
 {
-        switch (width)
-        {
+        switch (width) {
         case 8:
                 outb(value, port);
                 break;
@@ -420,40 +402,38 @@ acpi_os_write_port(
 
         return AE_OK;
 }
+
 EXPORT_SYMBOL(acpi_os_write_port);
 
 acpi_status
-acpi_os_read_memory(
-        acpi_physical_address   phys_addr,
-        u32                     *value,
-        u32                     width)
+acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
 {
-        u32                     dummy;
-        void __iomem            *virt_addr;
-        int                     iomem = 0;
+        u32 dummy;
+        void __iomem *virt_addr;
+        int iomem = 0;
 
         if (efi_enabled) {
                 if (EFI_MEMORY_WB & efi_mem_attributes(phys_addr)) {
                         /* HACK ALERT! We can use readb/w/l on real memory too.. */
-                        virt_addr = (void __iomem *) phys_to_virt(phys_addr);
+                        virt_addr = (void __iomem *)phys_to_virt(phys_addr);
                 } else {
                         iomem = 1;
                         virt_addr = ioremap(phys_addr, width);
                 }
         } else
-                virt_addr = (void __iomem *) phys_to_virt(phys_addr);
+                virt_addr = (void __iomem *)phys_to_virt(phys_addr);
         if (!value)
                 value = &dummy;
 
         switch (width) {
         case 8:
-                *(u8*) value = readb(virt_addr);
+                *(u8 *) value = readb(virt_addr);
                 break;
         case 16:
-                *(u16*) value = readw(virt_addr);
+                *(u16 *) value = readw(virt_addr);
                 break;
         case 32:
-                *(u32*) value = readl(virt_addr);
+                *(u32 *) value = readl(virt_addr);
                 break;
         default:
                 BUG();
@@ -468,24 +448,21 @@ acpi_os_read_memory(
 }
 
 acpi_status
-acpi_os_write_memory(
-        acpi_physical_address   phys_addr,
-        u32                     value,
-        u32                     width)
+acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
 {
-        void __iomem            *virt_addr;
-        int                     iomem = 0;
+        void __iomem *virt_addr;
+        int iomem = 0;
 
         if (efi_enabled) {
                 if (EFI_MEMORY_WB & efi_mem_attributes(phys_addr)) {
                         /* HACK ALERT! We can use writeb/w/l on real memory too */
-                        virt_addr = (void __iomem *) phys_to_virt(phys_addr);
+                        virt_addr = (void __iomem *)phys_to_virt(phys_addr);
                 } else {
                         iomem = 1;
                         virt_addr = ioremap(phys_addr, width);
                 }
         } else
-                virt_addr = (void __iomem *) phys_to_virt(phys_addr);
+                virt_addr = (void __iomem *)phys_to_virt(phys_addr);
 
         switch (width) {
         case 8:
@@ -510,7 +487,8 @@ acpi_os_write_memory(
 #ifdef CONFIG_ACPI_PCI
 
 acpi_status
-acpi_os_read_pci_configuration (struct acpi_pci_id *pci_id, u32 reg, void *value, u32 width)
+acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
+                               void *value, u32 width)
 {
         int result, size;
 
@@ -534,15 +512,17 @@ acpi_os_read_pci_configuration (struct acpi_pci_id *pci_id, u32 reg, void *value
         BUG_ON(!raw_pci_ops);
 
         result = raw_pci_ops->read(pci_id->segment, pci_id->bus,
-                                PCI_DEVFN(pci_id->device, pci_id->function),
-                                reg, size, value);
+                                   PCI_DEVFN(pci_id->device, pci_id->function),
+                                   reg, size, value);
 
         return (result ? AE_ERROR : AE_OK);
 }
+
 EXPORT_SYMBOL(acpi_os_read_pci_configuration);
 
 acpi_status
-acpi_os_write_pci_configuration (struct acpi_pci_id *pci_id, u32 reg, acpi_integer value, u32 width)
+acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
+                                acpi_integer value, u32 width)
 {
         int result, size;
 
@@ -563,56 +543,62 @@ acpi_os_write_pci_configuration (struct acpi_pci_id *pci_id, u32 reg, acpi_integ
         BUG_ON(!raw_pci_ops);
 
         result = raw_pci_ops->write(pci_id->segment, pci_id->bus,
-                                PCI_DEVFN(pci_id->device, pci_id->function),
-                                reg, size, value);
+                                    PCI_DEVFN(pci_id->device, pci_id->function),
+                                    reg, size, value);
 
         return (result ? AE_ERROR : AE_OK);
 }
 
 /* TODO: Change code to take advantage of driver model more */
-static void
-acpi_os_derive_pci_id_2 (
-        acpi_handle             rhandle,        /* upper bound  */
-        acpi_handle             chandle,        /* current node */
-        struct acpi_pci_id      **id,
-        int                     *is_bridge,
-        u8                      *bus_number)
+static void acpi_os_derive_pci_id_2(acpi_handle rhandle,        /* upper bound  */
+                                    acpi_handle chandle,        /* current node */
+                                    struct acpi_pci_id **id,
+                                    int *is_bridge, u8 * bus_number)
 {
-        acpi_handle             handle;
-        struct acpi_pci_id      *pci_id = *id;
-        acpi_status             status;
-        unsigned long           temp;
-        acpi_object_type        type;
-        u8                      tu8;
+        acpi_handle handle;
+        struct acpi_pci_id *pci_id = *id;
+        acpi_status status;
+        unsigned long temp;
+        acpi_object_type type;
+        u8 tu8;
 
         acpi_get_parent(chandle, &handle);
         if (handle != rhandle) {
-                acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge, bus_number);
+                acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
+                                        bus_number);
 
                 status = acpi_get_type(handle, &type);
-                if ( (ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE) )
+                if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
                         return;
 
-                status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &temp);
+                status =
+                    acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
+                                          &temp);
                 if (ACPI_SUCCESS(status)) {
-                        pci_id->device  = ACPI_HIWORD (ACPI_LODWORD (temp));
-                        pci_id->function = ACPI_LOWORD (ACPI_LODWORD (temp));
+                        pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
+                        pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
 
                         if (*is_bridge)
                                 pci_id->bus = *bus_number;
 
                         /* any nicer way to get bus number of bridge ? */
-                        status = acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8, 8);
-                        if (ACPI_SUCCESS(status) &&
-                            ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) {
-                                status = acpi_os_read_pci_configuration(pci_id, 0x18, &tu8, 8);
+                        status =
+                            acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8,
+                                                           8);
+                        if (ACPI_SUCCESS(status)
+                            && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) {
+                                status =
+                                    acpi_os_read_pci_configuration(pci_id, 0x18,
+                                                                   &tu8, 8);
                                 if (!ACPI_SUCCESS(status)) {
                                         /* Certainly broken...  FIX ME */
                                         return;
                                 }
                                 *is_bridge = 1;
                                 pci_id->bus = tu8;
-                                status = acpi_os_read_pci_configuration(pci_id, 0x19, &tu8, 8);
+                                status =
+                                    acpi_os_read_pci_configuration(pci_id, 0x19,
+                                                                   &tu8, 8);
                                 if (ACPI_SUCCESS(status)) {
                                         *bus_number = tu8;
                                 }
@@ -622,11 +608,9 @@ acpi_os_derive_pci_id_2 (
         }
 }
 
-void
-acpi_os_derive_pci_id (
-        acpi_handle             rhandle,        /* upper bound  */
-        acpi_handle             chandle,        /* current node */
-        struct acpi_pci_id      **id)
+void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound  */
+                           acpi_handle chandle, /* current node */
+                           struct acpi_pci_id **id)
 {
         int is_bridge = 1;
         u8 bus_number = (*id)->bus;
@@ -634,49 +618,39 @@ acpi_os_derive_pci_id (
         acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
 }
 
-#else /*!CONFIG_ACPI_PCI*/
+#else                           /*!CONFIG_ACPI_PCI */
 
 acpi_status
-acpi_os_write_pci_configuration (
-        struct acpi_pci_id      *pci_id,
-        u32                     reg,
-        acpi_integer            value,
-        u32                     width)
+acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id,
+                                u32 reg, acpi_integer value, u32 width)
 {
         return AE_SUPPORT;
 }
 
 acpi_status
-acpi_os_read_pci_configuration (
-        struct acpi_pci_id      *pci_id,
-        u32                     reg,
-        void                    *value,
-        u32                     width)
+acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id,
+                               u32 reg, void *value, u32 width)
 {
         return AE_SUPPORT;
 }
 
-void
-acpi_os_derive_pci_id (
-        acpi_handle             rhandle,        /* upper bound  */
-        acpi_handle             chandle,        /* current node */
-        struct acpi_pci_id      **id)
+void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound  */
+                           acpi_handle chandle, /* current node */
+                           struct acpi_pci_id **id)
 {
 }
 
-#endif /*CONFIG_ACPI_PCI*/
+#endif                          /*CONFIG_ACPI_PCI */
 
-static void
-acpi_os_execute_deferred (
-        void *context)
+static void acpi_os_execute_deferred(void *context)
 {
-        struct acpi_os_dpc      *dpc = NULL;
+        struct acpi_os_dpc *dpc = NULL;
 
-        ACPI_FUNCTION_TRACE ("os_execute_deferred");
+        ACPI_FUNCTION_TRACE("os_execute_deferred");
 
-        dpc = (struct acpi_os_dpc *) context;
+        dpc = (struct acpi_os_dpc *)context;
         if (!dpc) {
-                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid (NULL) context.\n"));
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n"));
                 return_VOID;
         }
 
@@ -688,21 +662,21 @@ acpi_os_execute_deferred (
 }
 
 acpi_status
-acpi_os_queue_for_execution(
-        u32                     priority,
-        acpi_osd_exec_callback  function,
-        void                    *context)
+acpi_os_queue_for_execution(u32 priority,
+                            acpi_osd_exec_callback function, void *context)
 {
-        acpi_status             status = AE_OK;
-        struct acpi_os_dpc      *dpc;
-        struct work_struct      *task;
+        acpi_status status = AE_OK;
+        struct acpi_os_dpc *dpc;
+        struct work_struct *task;
 
-        ACPI_FUNCTION_TRACE ("os_queue_for_execution");
+        ACPI_FUNCTION_TRACE("os_queue_for_execution");
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Scheduling function [%p(%p)] for deferred execution.\n", function, context));
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                          "Scheduling function [%p(%p)] for deferred execution.\n",
+                          function, context));
 
         if (!function)
-                return_ACPI_STATUS (AE_BAD_PARAMETER);
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
 
         /*
          * Allocate/initialize DPC structure.  Note that this memory will be
@@ -715,67 +689,65 @@ acpi_os_queue_for_execution(
          * from the same memory.
          */
 
-        dpc = kmalloc(sizeof(struct acpi_os_dpc)+sizeof(struct work_struct), GFP_ATOMIC);
+        dpc =
+            kmalloc(sizeof(struct acpi_os_dpc) + sizeof(struct work_struct),
+                    GFP_ATOMIC);
         if (!dpc)
-                return_ACPI_STATUS (AE_NO_MEMORY);
+                return_ACPI_STATUS(AE_NO_MEMORY);
 
         dpc->function = function;
         dpc->context = context;
 
-        task = (void *)(dpc+1);
-        INIT_WORK(task, acpi_os_execute_deferred, (void*)dpc);
+        task = (void *)(dpc + 1);
+        INIT_WORK(task, acpi_os_execute_deferred, (void *)dpc);
 
         if (!queue_work(kacpid_wq, task)) {
-                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Call to queue_work() failed.\n"));
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Call to queue_work() failed.\n"));
                 kfree(dpc);
                 status = AE_ERROR;
         }
 
-        return_ACPI_STATUS (status);
+        return_ACPI_STATUS(status);
 }
+
 EXPORT_SYMBOL(acpi_os_queue_for_execution);
 
-void
-acpi_os_wait_events_complete(
-        void *context)
+void acpi_os_wait_events_complete(void *context)
 {
         flush_workqueue(kacpid_wq);
 }
+
 EXPORT_SYMBOL(acpi_os_wait_events_complete);
 
 /*
  * Allocate the memory for a spinlock and initialize it.
  */
-acpi_status
-acpi_os_create_lock (
-        acpi_handle     *out_handle)
+acpi_status acpi_os_create_lock(acpi_handle * out_handle)
 {
         spinlock_t *lock_ptr;
 
-        ACPI_FUNCTION_TRACE ("os_create_lock");
+        ACPI_FUNCTION_TRACE("os_create_lock");
 
         lock_ptr = acpi_os_allocate(sizeof(spinlock_t));
 
         spin_lock_init(lock_ptr);
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Creating spinlock[%p].\n", lock_ptr));
+        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating spinlock[%p].\n", lock_ptr));
 
         *out_handle = lock_ptr;
 
-        return_ACPI_STATUS (AE_OK);
+        return_ACPI_STATUS(AE_OK);
 }
 
-
 /*
  * Deallocate the memory for a spinlock.
  */
-void
-acpi_os_delete_lock (
-        acpi_handle     handle)
+void acpi_os_delete_lock(acpi_handle handle)
 {
-        ACPI_FUNCTION_TRACE ("os_create_lock");
+        ACPI_FUNCTION_TRACE("os_create_lock");
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Deleting spinlock[%p].\n", handle));
+        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting spinlock[%p].\n", handle));
 
         acpi_os_free(handle);
 
@@ -783,30 +755,28 @@ acpi_os_delete_lock (
 }
 
 acpi_status
-acpi_os_create_semaphore(
-        u32             max_units,
-        u32             initial_units,
-        acpi_handle     *handle)
+acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
 {
-        struct semaphore        *sem = NULL;
+        struct semaphore *sem = NULL;
 
-        ACPI_FUNCTION_TRACE ("os_create_semaphore");
+        ACPI_FUNCTION_TRACE("os_create_semaphore");
 
         sem = acpi_os_allocate(sizeof(struct semaphore));
         if (!sem)
-                return_ACPI_STATUS (AE_NO_MEMORY);
+                return_ACPI_STATUS(AE_NO_MEMORY);
         memset(sem, 0, sizeof(struct semaphore));
 
         sema_init(sem, initial_units);
 
-        *handle = (acpi_handle*)sem;
+        *handle = (acpi_handle *) sem;
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n", *handle, initial_units));
+        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
+                          *handle, initial_units));
 
-        return_ACPI_STATUS (AE_OK);
+        return_ACPI_STATUS(AE_OK);
 }
-EXPORT_SYMBOL(acpi_os_create_semaphore);
 
+EXPORT_SYMBOL(acpi_os_create_semaphore);
 
 /*
  * TODO: A better way to delete semaphores?  Linux doesn't have a
@@ -815,25 +785,24 @@ EXPORT_SYMBOL(acpi_os_create_semaphore);
  * we at least check for blocked threads and signal/cancel them?
  */
 
-acpi_status
-acpi_os_delete_semaphore(
-        acpi_handle     handle)
+acpi_status acpi_os_delete_semaphore(acpi_handle handle)
 {
-        struct semaphore *sem = (struct semaphore*) handle;
+        struct semaphore *sem = (struct semaphore *)handle;
 
-        ACPI_FUNCTION_TRACE ("os_delete_semaphore");
+        ACPI_FUNCTION_TRACE("os_delete_semaphore");
 
         if (!sem)
-                return_ACPI_STATUS (AE_BAD_PARAMETER);
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
+        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
 
-        acpi_os_free(sem); sem =  NULL;
+        acpi_os_free(sem);
+        sem = NULL;
 
-        return_ACPI_STATUS (AE_OK);
+        return_ACPI_STATUS(AE_OK);
 }
-EXPORT_SYMBOL(acpi_os_delete_semaphore);
 
+EXPORT_SYMBOL(acpi_os_delete_semaphore);
 
 /*
  * TODO: The kernel doesn't have a 'down_timeout' function -- had to
@@ -844,31 +813,27 @@ EXPORT_SYMBOL(acpi_os_delete_semaphore);
  *
  * TODO: Support for units > 1?
  */
-acpi_status
-acpi_os_wait_semaphore(
-        acpi_handle             handle,
-        u32                     units,
-        u16                     timeout)
+acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
 {
-        acpi_status             status = AE_OK;
-        struct semaphore        *sem = (struct semaphore*)handle;
-        int                     ret = 0;
+        acpi_status status = AE_OK;
+        struct semaphore *sem = (struct semaphore *)handle;
+        int ret = 0;
 
-        ACPI_FUNCTION_TRACE ("os_wait_semaphore");
+        ACPI_FUNCTION_TRACE("os_wait_semaphore");
 
         if (!sem || (units < 1))
-                return_ACPI_STATUS (AE_BAD_PARAMETER);
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
 
         if (units > 1)
-                return_ACPI_STATUS (AE_SUPPORT);
+                return_ACPI_STATUS(AE_SUPPORT);
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n", handle, units, timeout));
+        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
+                          handle, units, timeout));
 
         if (in_atomic())
                 timeout = 0;
 
-        switch (timeout)
-        {
+        switch (timeout) {
                 /*
                  * No Wait:
                  * --------
@@ -876,8 +841,8 @@ acpi_os_wait_semaphore(
                  * acquire the semaphore if available otherwise return AE_TIME
                  * (a.k.a. 'would block').
                  */
-                case 0:
-                if(down_trylock(sem))
+        case 0:
+                if (down_trylock(sem))
                         status = AE_TIME;
                 break;
 
@@ -885,7 +850,7 @@ acpi_os_wait_semaphore(
                  * Wait Indefinitely:
                  * ------------------
                  */
-                case ACPI_WAIT_FOREVER:
+        case ACPI_WAIT_FOREVER:
                 down(sem);
                 break;
 
@@ -893,11 +858,11 @@ acpi_os_wait_semaphore(
                  * Wait w/ Timeout:
                  * ----------------
                  */
-                default:
+        default:
                 // TODO: A better timeout algorithm?
                 {
                         int i = 0;
-                        static const int quantum_ms = 1000/HZ;
+                        static const int quantum_ms = 1000 / HZ;
 
                         ret = down_trylock(sem);
                         for (i = timeout; (i > 0 && ret < 0); i -= quantum_ms) {
@@ -905,7 +870,7 @@ acpi_os_wait_semaphore(
                                 schedule_timeout(1);
                                 ret = down_trylock(sem);
                         }
-        
+
                         if (ret != 0)
                                 status = AE_TIME;
                 }
@@ -913,47 +878,48 @@ acpi_os_wait_semaphore(
         }
 
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Failed to acquire semaphore[%p|%d|%d], %s\n", 
-                        handle, units, timeout, acpi_format_exception(status)));
-        }
-        else {
-                ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Acquired semaphore[%p|%d|%d]\n", handle, units, timeout));
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Failed to acquire semaphore[%p|%d|%d], %s\n",
+                                  handle, units, timeout,
+                                  acpi_format_exception(status)));
+        } else {
+                ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
+                                  "Acquired semaphore[%p|%d|%d]\n", handle,
+                                  units, timeout));
         }
 
-        return_ACPI_STATUS (status);
+        return_ACPI_STATUS(status);
 }
-EXPORT_SYMBOL(acpi_os_wait_semaphore);
 
+EXPORT_SYMBOL(acpi_os_wait_semaphore);
 
 /*
  * TODO: Support for units > 1?
  */
-acpi_status
-acpi_os_signal_semaphore(
-    acpi_handle             handle,
-    u32                     units)
+acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 {
-        struct semaphore *sem = (struct semaphore *) handle;
+        struct semaphore *sem = (struct semaphore *)handle;
 
-        ACPI_FUNCTION_TRACE ("os_signal_semaphore");
+        ACPI_FUNCTION_TRACE("os_signal_semaphore");
 
         if (!sem || (units < 1))
-                return_ACPI_STATUS (AE_BAD_PARAMETER);
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
 
         if (units > 1)
-                return_ACPI_STATUS (AE_SUPPORT);
+                return_ACPI_STATUS(AE_SUPPORT);
 
-        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle, units));
+        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
+                          units));
 
         up(sem);
 
-        return_ACPI_STATUS (AE_OK);
+        return_ACPI_STATUS(AE_OK);
 }
+
 EXPORT_SYMBOL(acpi_os_signal_semaphore);
 
 #ifdef ACPI_FUTURE_USAGE
-u32
-acpi_os_get_line(char *buffer)
+u32 acpi_os_get_line(char *buffer)
 {
 
 #ifdef ENABLE_DEBUGGER
@@ -970,22 +936,21 @@ acpi_os_get_line(char *buffer)
 
         return 0;
 }
-#endif  /*  ACPI_FUTURE_USAGE  */
+#endif                          /*  ACPI_FUTURE_USAGE  */
 
 /* Assumes no unreadable holes inbetween */
-u8
-acpi_os_readable(void *ptr, acpi_size len)
+u8 acpi_os_readable(void *ptr, acpi_size len)
 {
-#if defined(__i386__) || defined(__x86_64__) 
+#if defined(__i386__) || defined(__x86_64__)
         char tmp;
-        return !__get_user(tmp, (char __user *)ptr) && !__get_user(tmp, (char __user *)ptr + len - 1);
+        return !__get_user(tmp, (char __user *)ptr)
+            && !__get_user(tmp, (char __user *)ptr + len - 1);
 #endif
         return 1;
 }
 
 #ifdef ACPI_FUTURE_USAGE
-u8
-acpi_os_writable(void *ptr, acpi_size len)
+u8 acpi_os_writable(void *ptr, acpi_size len)
 {
         /* could do dummy write (racy) or a kernel page table lookup.
            The later may be difficult at early boot when kmap doesn't work yet. */
@@ -993,8 +958,7 @@ acpi_os_writable(void *ptr, acpi_size len)
 }
 #endif
 
-u32
-acpi_os_get_thread_id (void)
+u32 acpi_os_get_thread_id(void)
 {
         if (!in_atomic())
                 return current->pid;
@@ -1002,13 +966,9 @@ acpi_os_get_thread_id (void)
         return 0;
 }
 
-acpi_status
-acpi_os_signal (
-    u32         function,
-    void        *info)
+acpi_status acpi_os_signal(u32 function, void *info)
 {
-        switch (function)
-        {
+        switch (function) {
         case ACPI_SIGNAL_FATAL:
                 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
                 break;
@@ -1028,13 +988,13 @@ acpi_os_signal (
 
         return AE_OK;
 }
+
 EXPORT_SYMBOL(acpi_os_signal);
 
-static int __init
-acpi_os_name_setup(char *str)
+static int __init acpi_os_name_setup(char *str)
 {
         char *p = acpi_os_name;
-        int count = ACPI_MAX_OVERRIDE_LEN-1;
+        int count = ACPI_MAX_OVERRIDE_LEN - 1;
 
         if (!str || !*str)
                 return 0;
@@ -1050,7 +1010,7 @@ acpi_os_name_setup(char *str)
         *p = 0;
 
         return 1;
-                
+
 }
 
 __setup("acpi_os_name=", acpi_os_name_setup);
@@ -1060,16 +1020,15 @@ __setup("acpi_os_name=", acpi_os_name_setup);
  * empty string disables _OSI
  * TBD additional string adds to _OSI
  */
-static int __init
-acpi_osi_setup(char *str)
+static int __init acpi_osi_setup(char *str)
 {
         if (str == NULL || *str == '\0') {
                 printk(KERN_INFO PREFIX "_OSI method disabled\n");
                 acpi_gbl_create_osi_method = FALSE;
-        } else
-        {
+        } else {
                 /* TBD */
-                printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n", str);
+                printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n",
+                       str);
         }
 
         return 1;
@@ -1078,8 +1037,7 @@ acpi_osi_setup(char *str)
 __setup("acpi_osi=", acpi_osi_setup);
 
 /* enable serialization to combat AE_ALREADY_EXISTS errors */
-static int __init
-acpi_serialize_setup(char *str)
+static int __init acpi_serialize_setup(char *str)
 {
         printk(KERN_INFO PREFIX "serialize enabled\n");
 
@@ -1099,8 +1057,7 @@ __setup("acpi_serialize", acpi_serialize_setup);
  * Run-time events on the same GPE this flag is available
  * to tell Linux to keep the wake-time GPEs enabled at run-time.
  */
-static int __init
-acpi_wake_gpes_always_on_setup(char *str)
+static int __init acpi_wake_gpes_always_on_setup(char *str)
 {
         printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
 
@@ -1111,8 +1068,7 @@ acpi_wake_gpes_always_on_setup(char *str)
 
 __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
 
-int __init
-acpi_hotkey_setup(char *str)
+int __init acpi_hotkey_setup(char *str)
 {
         acpi_specific_hotkey_enabled = TRUE;
         return 1;
@@ -1126,7 +1082,6 @@ __setup("acpi_specific_hotkey", acpi_hotkey_setup);
  */
 unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
 
-
 EXPORT_SYMBOL(max_cstate);
 
 /*
@@ -1137,12 +1092,10 @@ EXPORT_SYMBOL(max_cstate);
  *   that indicates whether we are at interrupt level.
  */
 
-unsigned long
-acpi_os_acquire_lock (
-        acpi_handle     handle)
+unsigned long acpi_os_acquire_lock(acpi_handle handle)
 {
         unsigned long flags;
-        spin_lock_irqsave((spinlock_t *)handle, flags);
+        spin_lock_irqsave((spinlock_t *) handle, flags);
         return flags;
 }
 
@@ -1150,15 +1103,11 @@ acpi_os_acquire_lock (
  * Release a spinlock. See above.
  */
 
-void
-acpi_os_release_lock (
-        acpi_handle     handle,
-        unsigned long   flags)
+void acpi_os_release_lock(acpi_handle handle, unsigned long flags)
 {
-        spin_unlock_irqrestore((spinlock_t *)handle, flags);
+        spin_unlock_irqrestore((spinlock_t *) handle, flags);
 }
 
-
 #ifndef ACPI_USE_LOCAL_CACHE
 
 /*******************************************************************************
@@ -1177,13 +1126,9 @@ acpi_os_release_lock (
  ******************************************************************************/
 
 acpi_status
-acpi_os_create_cache (
-    char                    *name,
-    u16                  size,
-    u16                  depth,
-    acpi_cache_t            **cache)
+acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
 {
-        *cache = kmem_cache_create (name, size, 0, 0, NULL, NULL);
+        *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
         return AE_OK;
 }
 
@@ -1199,12 +1144,10 @@ acpi_os_create_cache (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_os_purge_cache (
-    acpi_cache_t        *cache)
+acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
 {
-    (void) kmem_cache_shrink(cache);
-    return (AE_OK);
+        (void)kmem_cache_shrink(cache);
+        return (AE_OK);
 }
 
 /*******************************************************************************
@@ -1220,12 +1163,10 @@ acpi_os_purge_cache (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_os_delete_cache (
-    acpi_cache_t *cache)
+acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
 {
-    (void)kmem_cache_destroy(cache);
-    return (AE_OK);
+        (void)kmem_cache_destroy(cache);
+        return (AE_OK);
 }
 
 /*******************************************************************************
@@ -1242,13 +1183,10 @@ acpi_os_delete_cache (
  *
  ******************************************************************************/
 
-acpi_status
-acpi_os_release_object (
-    acpi_cache_t *cache,
-    void *object)
+acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
 {
-    kmem_cache_free(cache, object);
-    return (AE_OK);
+        kmem_cache_free(cache, object);
+        return (AE_OK);
 }
 
 /*******************************************************************************
@@ -1265,14 +1203,11 @@ acpi_os_release_object (
  *
  ******************************************************************************/
 
-void *
-acpi_os_acquire_object (
-    acpi_cache_t *cache)
+void *acpi_os_acquire_object(acpi_cache_t * cache)
 {
-    void *object = kmem_cache_alloc(cache, GFP_KERNEL);
-    WARN_ON(!object);
-    return object;
+        void *object = kmem_cache_alloc(cache, GFP_KERNEL);
+        WARN_ON(!object);
+        return object;
 }
 
 #endif
-