From 4be44fcd3bf648b782f4460fd06dfae6c42ded4b Mon Sep 17 00:00:00 2001 From: Len Brown Date: Fri, 5 Aug 2005 00:44:28 -0400 Subject: [ACPI] Lindent all ACPI files Signed-off-by: Len Brown --- drivers/acpi/osl.c | 567 ++++++++++++++++++++++++----------------------------- 1 file changed, 251 insertions(+), 316 deletions(-) (limited to 'drivers/acpi/osl.c') 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 - #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 - -- cgit v1.2.3