Merge 'acpi-2.6.12' branch into to-akpm
authorLen Brown <len.brown@intel.com>
Mon, 15 Aug 2005 19:56:23 +0000 (15:56 -0400)
committerLen Brown <len.brown@intel.com>
Mon, 15 Aug 2005 19:56:23 +0000 (15:56 -0400)
1  2 
Documentation/kernel-parameters.txt
drivers/acpi/osl.c

index a998a8c2f95baee78ec3080a244a4ff8fa280fa6,3c684ef6352ed820270fbcabd33beffe6cffdbff..3d5cd7a09b2fc1aa56b6c197ee8d35df7116ec4d
@@@ -37,7 -37,7 +37,7 @@@ restrictions referred to are that the r
        IA-32   IA-32 aka i386 architecture is enabled.
        IA-64   IA-64 architecture is enabled.
        IOSCHED More than one I/O scheduler is enabled.
 -      IP_PNP  IP DCHP, BOOTP, or RARP is enabled.
 +      IP_PNP  IP DHCP, BOOTP, or RARP is enabled.
        ISAPNP  ISA PnP code is enabled.
        ISDN    Appropriate ISDN support is enabled.
        JOY     Appropriate joystick support is enabled.
@@@ -159,6 -159,11 +159,11 @@@ running once the system is up
  
        acpi_fake_ecdt  [HW,ACPI] Workaround failure due to BIOS lacking ECDT
  
+       acpi_generic_hotkey [HW,ACPI]
+                       Allow consolidated generic hotkey driver to
+                       over-ride platform specific driver.
+                       See also Documentation/acpi-hotkey.txt.
        ad1816=         [HW,OSS]
                        Format: <io>,<irq>,<dma>,<dma2>
                        See also Documentation/sound/oss/AD1816.
        cpia_pp=        [HW,PPT]
                        Format: { parport<nr> | auto | none }
  
 +      crashkernel=nn[KMG]@ss[KMG]
 +                      [KNL] Reserve a chunk of physical memory to
 +                      hold a kernel to switch to with kexec on panic.
 +
        cs4232=         [HW,OSS]
                        Format: <io>,<irq>,<dma>,<dma2>,<mpuio>,<mpuirq>
  
                        Format: {"as"|"cfq"|"deadline"|"noop"}
                        See Documentation/block/as-iosched.txt
                        and Documentation/block/deadline-iosched.txt for details.
 +      elfcorehdr=     [IA-32]
 +                      Specifies physical address of start of kernel core image
 +                      elf header.
 +                      See Documentation/kdump.txt for details.
  
        enforcing       [SELINUX] Set initial enforcing status.
                        Format: {"0" | "1"}
  
        i810=           [HW,DRM]
  
 +      i8k.ignore_dmi  [HW] Continue probing hardware even if DMI data
 +                      indicates that the driver is running on unsupported
 +                      hardware.
        i8k.force       [HW] Activate i8k driver even if SMM BIOS signature
                        does not match list of supported models.
        i8k.power_status
        ips=            [HW,SCSI] Adaptec / IBM ServeRAID controller
                        See header of drivers/scsi/ips.c.
  
 +      irqfixup        [HW]
 +                      When an interrupt is not handled search all handlers
 +                      for it. Intended to get systems with badly broken
 +                      firmware running.
 +
 +      irqpoll         [HW]
 +                      When an interrupt is not handled search all handlers
 +                      for it. Also check all handlers each timer
 +                      interrupt. Intended to get systems with badly broken
 +                      firmware running.
 +
        isapnp=         [ISAPNP]
                        Format: <RDP>, <reset>, <pci_scan>, <verbosity>
  
        maxcpus=        [SMP] Maximum number of processors that an SMP kernel
                        should make use of
  
 +      max_addr=[KMG]  [KNL,BOOT,ia64] All physical memory greater than or
 +                      equal to this physical address is ignored.
 +
        max_luns=       [SCSI] Maximum number of LUNs to probe
                        Should be between 1 and 2^32-1.
  
                irqmask=0xMMMM          [IA-32] Set a bit mask of IRQs allowed to be assigned
                                        automatically to PCI devices. You can make the kernel
                                        exclude IRQs of your ISA cards this way.
 +              pirqaddr=0xAAAAA        [IA-32] Specify the physical address
 +                                      of the PIRQ table (normally generated
 +                                      by the BIOS) if it is outside the
 +                                      F0000h-100000h range.
                lastbus=N               [IA-32] Scan all buses till bus #N. Can be useful
                                        if the kernel is unable to find your secondary buses
                                        and you want to tell it explicitly which ones they are.
                        See Documentation/ramdisk.txt.
  
        psmouse.proto=  [HW,MOUSE] Highest PS2 mouse protocol extension to
 -                      probe for (bare|imps|exps).
 +                      probe for (bare|imps|exps|lifebook|any).
        psmouse.rate=   [HW,MOUSE] Set desired mouse report rate, in reports
                        per second.
        psmouse.resetafter=
diff --combined drivers/acpi/osl.c
index 9127760d36c590765d72bfaa80363522da2f54cc,c212d19443c5f0ce238e2c0abe3254512612127c..81f0eb863a76549353143d277b0f78b4e0234234
  
  #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
@@@ -65,9 -69,9 +65,9 @@@ 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;
+ int acpi_specific_hotkey_enabled = TRUE;
  EXPORT_SYMBOL(acpi_specific_hotkey_enabled);
  
  static unsigned int acpi_irq_irq;
@@@ -75,12 -79,14 +75,12 @@@ static acpi_osd_handler acpi_irq_handle
  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
@@@ -88,8 -94,7 +88,8 @@@
         */
  #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
        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,
        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
  #endif
  }
  
 -void *
 -acpi_os_allocate(acpi_size size)
 +extern int acpi_in_resume;
 +void *acpi_os_allocate(acpi_size size)
  {
 -      return kmalloc(size, GFP_KERNEL);
 +      if (acpi_in_resume)
 +              return kmalloc(size, GFP_ATOMIC);
 +      else
 +              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;
                }
        }
  }
  
  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);
                }
                        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)
        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);
  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;
        }
  
  }
  
  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
        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;
  
        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);
   * 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;
                us -= delay;
        }
  }
 +
  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;
  
        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();
  
        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;
  
        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();
  }
  
  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:
  #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;
  
        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;
  
        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;
                                }
        }
  }
  
 -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;
        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;
        }
  
  }
  
  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
         * 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);
  
  }
  
  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
   * 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
   *
   * 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:
                 * --------
                 * 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;
  
                 * Wait Indefinitely:
                 * ------------------
                 */
 -              case ACPI_WAIT_FOREVER:
 +      case ACPI_WAIT_FOREVER:
                down(sem);
                break;
  
                 * 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) {
                                schedule_timeout(1);
                                ret = down_trylock(sem);
                        }
 -      
 +
                        if (ret != 0)
                                status = AE_TIME;
                }
        }
  
        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
  
        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. */
  }
  #endif
  
 -u32
 -acpi_os_get_thread_id (void)
 +u32 acpi_os_get_thread_id(void)
  {
        if (!in_atomic())
                return current->pid;
        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;
  
        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;
        *p = 0;
  
        return 1;
 -              
 +
  }
  
  __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;
  __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");
  
@@@ -1057,7 -1095,8 +1057,7 @@@ __setup("acpi_serialize", acpi_serializ
   * 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");
  
  
  __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;
+       acpi_specific_hotkey_enabled = FALSE;
        return 1;
  }
  
- __setup("acpi_specific_hotkey", acpi_hotkey_setup);
+ __setup("acpi_generic_hotkey", acpi_hotkey_setup);
  
  /*
   * max_cstate is defined in the base kernel so modules can
   */
  unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
  
 -
  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;
  }
  
   * 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
  
  /*******************************************************************************
   ******************************************************************************/
  
  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;
  }
  
   *
   ******************************************************************************/
  
 -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);
  }
  
  /*******************************************************************************
   *
   ******************************************************************************/
  
 -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);
  }
  
  /*******************************************************************************
   *
   ******************************************************************************/
  
 -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);
  }
  
  /*******************************************************************************
   *
   ******************************************************************************/
  
 -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
 -