Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux...
authorLinus Torvalds <torvalds@linux-foundation.org>
Mon, 16 Aug 2010 00:37:07 +0000 (17:37 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Mon, 16 Aug 2010 00:37:07 +0000 (17:37 -0700)
* 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-acpi-2.6:
  gcc-4.6: ACPI: fix unused but set variables in ACPI
  ACPI thermal: make procfs I/F depend on CONFIG_ACPI_PROCFS
  ACPI video: make procfs I/F depend on CONFIG_ACPI_PROCFS
  ACPI processor: remove deprecated ACPI procfs I/F
  ACPI power_resource: remove unused procfs I/F
  ACPI: remove deprecated ACPI procfs I/F
  ACPI: introduce drivers/acpi/sysfs.c
  ACPI: introduce module parameter acpi.aml_debug_output
  ACPI: introduce drivers/acpi/debugfs.c
  ACPI, APEI, ERST debug support
  ACPI, APEI, Manage GHES as platform devices
  ACPI, APEI, Rename CPER and GHES severity constants
  ACPI, APEI, Fix a typo of error path of apei_resources_request
  ACPI / ACPICA: Fix reference counting problems with GPE handlers
  ACPI: Add the check of ADR flag in course of finding ACPI handle for PCI device
  ACPI / Sleep: Drop acpi_suspend_finish()
  ACPI / Sleep: Consolidate suspend and hibernation routines
  ACPI / Wakeup: Simplify enabling of wakeup devices
  ACPI / Sleep: Rework enabling wakeup devices
  ACPI / Sleep: Free NVS copy if suspending of devices fails

Fixed up totally buggered "ACPI: fix unused but set variables in ACPI"
patch that doesn't even compile in the merge.

Thanks to Sedat Dilek <sedat.dilek@googlemail.com> for noticing the
breakage before I even pulled.  And a big "Grrr.." at Len for not even
bothering to compile the tree before asking me to pull.

40 files changed:
Documentation/acpi/method-customizing.txt
arch/x86/kernel/cpu/mcheck/mce-apei.c
drivers/acpi/Kconfig
drivers/acpi/Makefile
drivers/acpi/acpica/acevents.h
drivers/acpi/acpica/acglobal.h
drivers/acpi/acpica/aclocal.h
drivers/acpi/acpica/evgpe.c
drivers/acpi/acpica/evxface.c
drivers/acpi/acpica/evxfevnt.c
drivers/acpi/acpica/utmutex.c
drivers/acpi/apei/Kconfig
drivers/acpi/apei/Makefile
drivers/acpi/apei/apei-base.c
drivers/acpi/apei/erst-dbg.c [new file with mode: 0644]
drivers/acpi/apei/ghes.c
drivers/acpi/apei/hest.c
drivers/acpi/bus.c
drivers/acpi/debug.c [deleted file]
drivers/acpi/debugfs.c [new file with mode: 0644]
drivers/acpi/glue.c
drivers/acpi/internal.h
drivers/acpi/numa.c
drivers/acpi/osl.c
drivers/acpi/power.c
drivers/acpi/proc.c
drivers/acpi/processor_driver.c
drivers/acpi/processor_idle.c
drivers/acpi/processor_thermal.c
drivers/acpi/processor_throttling.c
drivers/acpi/sleep.c
drivers/acpi/sleep.h
drivers/acpi/sysfs.c [moved from drivers/acpi/system.c with 57% similarity]
drivers/acpi/thermal.c
drivers/acpi/video.c
drivers/acpi/wakeup.c
drivers/ata/libata-acpi.c
include/acpi/acpixf.h
include/acpi/processor.h
include/linux/cper.h

index e628cd23ca8093315b6d3e31ccd4d0e3204df17d..3e1d25aee3fb2037b34af127214a1652691fa2f2 100644 (file)
@@ -19,6 +19,8 @@ Note: Only ACPI METHOD can be overridden, any other object types like
       "Device", "OperationRegion", are not recognized.
 Note: The same ACPI control method can be overridden for many times,
       and it's always the latest one that used by Linux/kernel.
+Note: To get the ACPI debug object output (Store (AAAA, Debug)),
+      please run "echo 1 > /sys/module/acpi/parameters/aml_debug_output".
 
 1. override an existing method
    a) get the ACPI table via ACPI sysfs I/F. e.g. to get the DSDT,
index 745b54f9be89fe02d3043bdb24032016deb2d7db..8209472b27a5ef2e91b88c02841ee702a5a906ee 100644 (file)
@@ -80,7 +80,7 @@ int apei_write_mce(struct mce *m)
        rcd.hdr.revision = CPER_RECORD_REV;
        rcd.hdr.signature_end = CPER_SIG_END;
        rcd.hdr.section_count = 1;
-       rcd.hdr.error_severity = CPER_SER_FATAL;
+       rcd.hdr.error_severity = CPER_SEV_FATAL;
        /* timestamp, platform_id, partition_id are all invalid */
        rcd.hdr.validation_bits = 0;
        rcd.hdr.record_length = sizeof(rcd);
@@ -96,7 +96,7 @@ int apei_write_mce(struct mce *m)
        rcd.sec_hdr.validation_bits = 0;
        rcd.sec_hdr.flags = CPER_SEC_PRIMARY;
        rcd.sec_hdr.section_type = CPER_SECTION_TYPE_MCE;
-       rcd.sec_hdr.section_severity = CPER_SER_FATAL;
+       rcd.sec_hdr.section_severity = CPER_SEV_FATAL;
 
        memcpy(&rcd.mce, m, sizeof(*m));
 
index 08e0140920e17caa6864e2bed5884fe93095d8dd..b811f2173f6f167c84700040fe2720bafb43156f 100644 (file)
@@ -54,17 +54,10 @@ config ACPI_PROCFS
          they have been replaced by functions in /sys.
          The deprecated files (and their replacements) include:
 
-         /proc/acpi/sleep (/sys/power/state)
-         /proc/acpi/info (/sys/module/acpi/parameters/acpica_version)
-         /proc/acpi/dsdt (/sys/firmware/acpi/tables/DSDT)
-         /proc/acpi/fadt (/sys/firmware/acpi/tables/FACP)
-         /proc/acpi/debug_layer (/sys/module/acpi/parameters/debug_layer)
-         /proc/acpi/debug_level (/sys/module/acpi/parameters/debug_level)
-         /proc/acpi/processor/*/power (/sys/devices/system/cpu/*/cpuidle/*)
-         /proc/acpi/processor/*/performance (/sys/devices/system/cpu/*/
-               cpufreq/*)
          /proc/acpi/processor/*/throttling (/sys/class/thermal/
                cooling_device*/*)
+         /proc/acpi/video/*/brightness (/sys/class/backlight/)
+         /proc/acpi/thermal_zone/*/* (/sys/class/thermal/)
          This option has no effect on /proc/acpi/ files
          and functions which do not yet exist in /sys.
 
index 833b582d17625dc30b73e89291c9ade964414e1f..3d031d02e54b556a038be7ae2a64ebde1fa92f84 100644 (file)
@@ -37,8 +37,9 @@ acpi-y                                += ec.o
 acpi-$(CONFIG_ACPI_DOCK)       += dock.o
 acpi-y                         += pci_root.o pci_link.o pci_irq.o pci_bind.o
 acpi-y                         += power.o
-acpi-y                         += system.o event.o
-acpi-$(CONFIG_ACPI_DEBUG)      += debug.o
+acpi-y                         += event.o
+acpi-y                         += sysfs.o
+acpi-$(CONFIG_DEBUG_FS)                += debugfs.o
 acpi-$(CONFIG_ACPI_NUMA)       += numa.o
 acpi-$(CONFIG_ACPI_PROCFS_POWER) += cm_sbs.o
 ifdef CONFIG_ACPI_VIDEO
index e0e6affb0d8044fe4cba68fca00e558d6723afa5..36867cd70eacf3f9495325c71200bc688d705510 100644 (file)
@@ -82,6 +82,10 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info);
 
 acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
+acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
+
+acpi_status acpi_raw_disable_gpe(struct acpi_gpe_event_info *gpe_event_info);
+
 struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
                                                       u32 gpe_number);
 
index 18e796fe429595af3c92787ccd8a66c5c2d275c9..1d192142c69114ea65ecec63c98209190aa2eb83 100644 (file)
@@ -108,7 +108,7 @@ u8 ACPI_INIT_GLOBAL(acpi_gbl_use_default_register_widths, TRUE);
 /*
  * Optionally enable output from the AML Debug Object.
  */
-u8 ACPI_INIT_GLOBAL(acpi_gbl_enable_aml_debug_object, FALSE);
+u32 ACPI_INIT_GLOBAL(acpi_gbl_enable_aml_debug_object, FALSE);
 
 /*
  * Optionally copy the entire DSDT to local memory (instead of simply
index 1ee0bcf399aaf8fd9c0e24054a08bcd282187fd5..df85b53a674fc33105fa1434b3800db7ab26a423 100644 (file)
@@ -412,6 +412,7 @@ struct acpi_handler_info {
        acpi_event_handler address;     /* Address of handler, if any */
        void *context;          /* Context to be passed to handler */
        struct acpi_namespace_node *method_node;        /* Method node for this GPE level (saved) */
+       u8 orig_flags;          /* Original misc info about this GPE */
 };
 
 union acpi_gpe_dispatch_info {
index 7a6a3e6f4be09dbc7522d17c10d3b03be579227d..f226eac314db587668a32e8cc75cd6bfd931b5f4 100644 (file)
@@ -135,6 +135,79 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 }
 
 
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_raw_enable_gpe
+ *
+ * PARAMETERS:  gpe_event_info  - GPE to enable
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
+ *              hardware-enabled.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
+{
+       acpi_status status = AE_OK;
+
+       if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
+               return_ACPI_STATUS(AE_LIMIT);
+       }
+
+       gpe_event_info->runtime_count++;
+       if (gpe_event_info->runtime_count == 1) {
+               status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
+               if (ACPI_SUCCESS(status)) {
+                       status = acpi_ev_enable_gpe(gpe_event_info);
+               }
+
+               if (ACPI_FAILURE(status)) {
+                       gpe_event_info->runtime_count--;
+               }
+       }
+
+       return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_raw_disable_gpe
+ *
+ * PARAMETERS:  gpe_event_info  - GPE to disable
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Remove a reference to a GPE. When the last reference is
+ *              removed, the GPE is hardware-disabled.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_raw_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
+{
+       acpi_status status = AE_OK;
+
+       if (!gpe_event_info->runtime_count) {
+               return_ACPI_STATUS(AE_LIMIT);
+       }
+
+       gpe_event_info->runtime_count--;
+       if (!gpe_event_info->runtime_count) {
+               status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
+               if (ACPI_SUCCESS(status)) {
+                       status = acpi_hw_low_set_gpe(gpe_event_info,
+                                                    ACPI_GPE_DISABLE);
+               }
+
+               if (ACPI_FAILURE(status)) {
+                       gpe_event_info->runtime_count++;
+               }
+       }
+
+       return_ACPI_STATUS(status);
+}
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_low_get_gpe_info
index 4a531cdf79423e7f9328318fc3cbd8f4b17a4f08..14e48add32fa0ede706a120b87d3a885e8ecbf0f 100644 (file)
@@ -691,12 +691,22 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
                return_ACPI_STATUS(status);
        }
 
+       /* Allocate memory for the handler object */
+
+       handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));
+       if (!handler) {
+               status = AE_NO_MEMORY;
+               goto unlock_and_exit;
+       }
+
+       flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
+
        /* Ensure that we have a valid GPE number */
 
        gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
        if (!gpe_event_info) {
                status = AE_BAD_PARAMETER;
-               goto unlock_and_exit;
+               goto free_and_exit;
        }
 
        /* Make sure that there isn't a handler there already */
@@ -704,24 +714,30 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
        if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
            ACPI_GPE_DISPATCH_HANDLER) {
                status = AE_ALREADY_EXISTS;
-               goto unlock_and_exit;
+               goto free_and_exit;
        }
 
        /* Allocate and init handler object */
 
-       handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));
-       if (!handler) {
-               status = AE_NO_MEMORY;
-               goto unlock_and_exit;
-       }
-
        handler->address = address;
        handler->context = context;
        handler->method_node = gpe_event_info->dispatch.method_node;
+       handler->orig_flags = gpe_event_info->flags &
+                       (ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+
+       /*
+        * If the GPE is associated with a method and it cannot wake up the
+        * system from sleep states, it was enabled automatically during
+        * initialization, so it has to be disabled now to avoid spurious
+        * execution of the handler.
+        */
+
+       if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD)
+           && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE))
+               (void)acpi_raw_disable_gpe(gpe_event_info);
 
        /* Install the handler */
 
-       flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
        gpe_event_info->dispatch.handler = handler;
 
        /* Setup up dispatch flags to indicate handler (vs. method) */
@@ -735,6 +751,11 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
 unlock_and_exit:
        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
        return_ACPI_STATUS(status);
+
+free_and_exit:
+       acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+       ACPI_FREE(handler);
+       goto unlock_and_exit;
 }
 
 ACPI_EXPORT_SYMBOL(acpi_install_gpe_handler)
@@ -770,11 +791,17 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                return_ACPI_STATUS(AE_BAD_PARAMETER);
        }
 
+       /* Make sure all deferred tasks are completed */
+
+       acpi_os_wait_events_complete(NULL);
+
        status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }
 
+       flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
+
        /* Ensure that we have a valid GPE number */
 
        gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
@@ -798,34 +825,34 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                goto unlock_and_exit;
        }
 
-       /* Make sure all deferred tasks are completed */
-
-       (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
-       acpi_os_wait_events_complete(NULL);
-       status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
-       if (ACPI_FAILURE(status)) {
-               return_ACPI_STATUS(status);
-       }
-
        /* Remove the handler */
 
-       flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
        handler = gpe_event_info->dispatch.handler;
 
        /* Restore Method node (if any), set dispatch flags */
 
        gpe_event_info->dispatch.method_node = handler->method_node;
-       gpe_event_info->flags &= ~ACPI_GPE_DISPATCH_MASK;       /* Clear bits */
-       if (handler->method_node) {
-               gpe_event_info->flags |= ACPI_GPE_DISPATCH_METHOD;
-       }
-       acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+       gpe_event_info->flags &=
+               ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+       gpe_event_info->flags |= handler->orig_flags;
+
+       /*
+        * If the GPE was previously associated with a method and it cannot wake
+        * up the system from sleep states, it should be enabled at this point
+        * to restore the post-initialization configuration.
+        */
+
+       if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD)
+           && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE))
+               (void)acpi_raw_enable_gpe(gpe_event_info);
 
        /* Now we can free the handler object */
 
        ACPI_FREE(handler);
 
-      unlock_and_exit:
+unlock_and_exit:
+       acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+
        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
        return_ACPI_STATUS(status);
 }
index 0ec900da5794e96dedb5ed413165c34a0487bfd1..304825528d4803d22e025b9fb6d2220b10851d0b 100644 (file)
@@ -294,7 +294,7 @@ ACPI_EXPORT_SYMBOL(acpi_gpe_wakeup)
  ******************************************************************************/
 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
 {
-       acpi_status status = AE_OK;
+       acpi_status status = AE_BAD_PARAMETER;
        struct acpi_gpe_event_info *gpe_event_info;
        acpi_cpu_flags flags;
 
@@ -305,28 +305,10 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
        /* Ensure that we have a valid GPE number */
 
        gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
-       if (!gpe_event_info) {
-               status = AE_BAD_PARAMETER;
-               goto unlock_and_exit;
+       if (gpe_event_info) {
+               status = acpi_raw_enable_gpe(gpe_event_info);
        }
 
-       if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
-               status = AE_LIMIT;      /* Too many references */
-               goto unlock_and_exit;
-       }
-
-       gpe_event_info->runtime_count++;
-       if (gpe_event_info->runtime_count == 1) {
-               status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
-               if (ACPI_SUCCESS(status)) {
-                       status = acpi_ev_enable_gpe(gpe_event_info);
-               }
-               if (ACPI_FAILURE(status)) {
-                       gpe_event_info->runtime_count--;
-               }
-       }
-
-unlock_and_exit:
        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
        return_ACPI_STATUS(status);
 }
@@ -348,7 +330,7 @@ ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
  ******************************************************************************/
 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
 {
-       acpi_status status = AE_OK;
+       acpi_status status = AE_BAD_PARAMETER;
        struct acpi_gpe_event_info *gpe_event_info;
        acpi_cpu_flags flags;
 
@@ -359,32 +341,10 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
        /* Ensure that we have a valid GPE number */
 
        gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
-       if (!gpe_event_info) {
-               status = AE_BAD_PARAMETER;
-               goto unlock_and_exit;
-       }
-
-       /* Hardware-disable a runtime GPE on removal of the last reference */
-
-       if (!gpe_event_info->runtime_count) {
-               status = AE_LIMIT;      /* There are no references to remove */
-               goto unlock_and_exit;
+       if (gpe_event_info) {
+               status = acpi_raw_disable_gpe(gpe_event_info) ;
        }
 
-       gpe_event_info->runtime_count--;
-       if (!gpe_event_info->runtime_count) {
-               status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
-               if (ACPI_SUCCESS(status)) {
-                       status =
-                           acpi_hw_low_set_gpe(gpe_event_info,
-                                               ACPI_GPE_DISABLE);
-               }
-               if (ACPI_FAILURE(status)) {
-                       gpe_event_info->runtime_count++;
-               }
-       }
-
-unlock_and_exit:
        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
        return_ACPI_STATUS(status);
 }
@@ -411,7 +371,6 @@ acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number)
        acpi_status status = AE_OK;
        struct acpi_gpe_event_info *gpe_event_info;
        acpi_cpu_flags flags;
-       u8 disable = 0;
 
        ACPI_FUNCTION_TRACE(acpi_gpe_can_wake);
 
@@ -430,15 +389,12 @@ acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number)
        }
 
        gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
-       disable = (gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD)
-               && gpe_event_info->runtime_count;
+       if (gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD) {
+               (void)acpi_raw_disable_gpe(gpe_event_info);
+       }
 
 unlock_and_exit:
        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
-
-       if (disable)
-               status = acpi_disable_gpe(gpe_device, gpe_number);
-
        return_ACPI_STATUS(status);
 }
 ACPI_EXPORT_SYMBOL(acpi_gpe_can_wake)
index 058b3df48271ac39f622e819ceadc329a8ecd9fb..f5cca3a1300c60c1d3fae972389031d27782e1a1 100644 (file)
@@ -279,13 +279,10 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 
 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
 {
-       acpi_thread_id this_thread_id;
-
        ACPI_FUNCTION_NAME(ut_release_mutex);
 
-       this_thread_id = acpi_os_get_thread_id();
        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Thread %p releasing Mutex [%s]\n",
-                         ACPI_CAST_PTR(void, this_thread_id),
+                         ACPI_CAST_PTR(void, acpi_os_get_thread_id()),
                          acpi_ut_get_mutex_name(mutex_id)));
 
        if (mutex_id > ACPI_MAX_MUTEX) {
index f8c668f27b5a29eda7fbcc93357fbe5f1724fd1f..907e350f1c7df58370cb0e68a399b91d903ec466 100644 (file)
@@ -28,3 +28,12 @@ config ACPI_APEI_EINJ
          EINJ provides a hardware error injection mechanism, it is
          mainly used for debugging and testing the other parts of
          APEI and some other RAS features.
+
+config ACPI_APEI_ERST_DEBUG
+       tristate "APEI Error Record Serialization Table (ERST) Debug Support"
+       depends on ACPI_APEI
+       help
+         ERST is a way provided by APEI to save and retrieve hardware
+         error infomation to and from a persistent store. Enable this
+         if you want to debugging and testing the ERST kernel support
+         and firmware implementation.
index b13b03a177896263fc5e9fb1ebbd6e88653beaba..d1d1bc0a4ee1623006f5eaa787595e4b1562b607 100644 (file)
@@ -1,5 +1,6 @@
 obj-$(CONFIG_ACPI_APEI)                += apei.o
 obj-$(CONFIG_ACPI_APEI_GHES)   += ghes.o
 obj-$(CONFIG_ACPI_APEI_EINJ)   += einj.o
+obj-$(CONFIG_ACPI_APEI_ERST_DEBUG) += erst-dbg.o
 
 apei-y := apei-base.o hest.o cper.o erst.o
index 216e1e948ff6dcc5823289300453ab3516b48072..73fd0c7487c1ae0b1311f4d7e1c048ddc809153a 100644 (file)
@@ -482,14 +482,14 @@ err_unmap_ioport:
        list_for_each_entry(res, &resources->ioport, list) {
                if (res == res_bak)
                        break;
-               release_mem_region(res->start, res->end - res->start);
+               release_region(res->start, res->end - res->start);
        }
        res_bak = NULL;
 err_unmap_iomem:
        list_for_each_entry(res, &resources->iomem, list) {
                if (res == res_bak)
                        break;
-               release_region(res->start, res->end - res->start);
+               release_mem_region(res->start, res->end - res->start);
        }
        return -EINVAL;
 }
diff --git a/drivers/acpi/apei/erst-dbg.c b/drivers/acpi/apei/erst-dbg.c
new file mode 100644 (file)
index 0000000..5281ddd
--- /dev/null
@@ -0,0 +1,207 @@
+/*
+ * APEI Error Record Serialization Table debug support
+ *
+ * ERST is a way provided by APEI to save and retrieve hardware error
+ * infomation to and from a persistent store. This file provide the
+ * debugging/testing support for ERST kernel support and firmware
+ * implementation.
+ *
+ * Copyright 2010 Intel Corp.
+ *   Author: Huang Ying <ying.huang@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <acpi/apei.h>
+#include <linux/miscdevice.h>
+
+#include "apei-internal.h"
+
+#define ERST_DBG_PFX                   "ERST DBG: "
+
+#define ERST_DBG_RECORD_LEN_MAX                4096
+
+static void *erst_dbg_buf;
+static unsigned int erst_dbg_buf_len;
+
+/* Prevent erst_dbg_read/write from being invoked concurrently */
+static DEFINE_MUTEX(erst_dbg_mutex);
+
+static int erst_dbg_open(struct inode *inode, struct file *file)
+{
+       if (erst_disable)
+               return -ENODEV;
+
+       return nonseekable_open(inode, file);
+}
+
+static long erst_dbg_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
+{
+       int rc;
+       u64 record_id;
+       u32 record_count;
+
+       switch (cmd) {
+       case APEI_ERST_CLEAR_RECORD:
+               rc = copy_from_user(&record_id, (void __user *)arg,
+                                   sizeof(record_id));
+               if (rc)
+                       return -EFAULT;
+               return erst_clear(record_id);
+       case APEI_ERST_GET_RECORD_COUNT:
+               rc = erst_get_record_count();
+               if (rc < 0)
+                       return rc;
+               record_count = rc;
+               rc = put_user(record_count, (u32 __user *)arg);
+               if (rc)
+                       return rc;
+               return 0;
+       default:
+               return -ENOTTY;
+       }
+}
+
+static ssize_t erst_dbg_read(struct file *filp, char __user *ubuf,
+                            size_t usize, loff_t *off)
+{
+       int rc;
+       ssize_t len = 0;
+       u64 id;
+
+       if (*off != 0)
+               return -EINVAL;
+
+       if (mutex_lock_interruptible(&erst_dbg_mutex) != 0)
+               return -EINTR;
+
+retry_next:
+       rc = erst_get_next_record_id(&id);
+       if (rc)
+               goto out;
+       /* no more record */
+       if (id == APEI_ERST_INVALID_RECORD_ID)
+               goto out;
+retry:
+       rc = len = erst_read(id, erst_dbg_buf, erst_dbg_buf_len);
+       /* The record may be cleared by others, try read next record */
+       if (rc == -ENOENT)
+               goto retry_next;
+       if (rc < 0)
+               goto out;
+       if (len > ERST_DBG_RECORD_LEN_MAX) {
+               pr_warning(ERST_DBG_PFX
+                          "Record (ID: 0x%llx) length is too long: %zd\n",
+                          id, len);
+               rc = -EIO;
+               goto out;
+       }
+       if (len > erst_dbg_buf_len) {
+               kfree(erst_dbg_buf);
+               rc = -ENOMEM;
+               erst_dbg_buf = kmalloc(len, GFP_KERNEL);
+               if (!erst_dbg_buf)
+                       goto out;
+               erst_dbg_buf_len = len;
+               goto retry;
+       }
+
+       rc = -EINVAL;
+       if (len > usize)
+               goto out;
+
+       rc = -EFAULT;
+       if (copy_to_user(ubuf, erst_dbg_buf, len))
+               goto out;
+       rc = 0;
+out:
+       mutex_unlock(&erst_dbg_mutex);
+       return rc ? rc : len;
+}
+
+static ssize_t erst_dbg_write(struct file *filp, const char __user *ubuf,
+                             size_t usize, loff_t *off)
+{
+       int rc;
+       struct cper_record_header *rcd;
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EPERM;
+
+       if (usize > ERST_DBG_RECORD_LEN_MAX) {
+               pr_err(ERST_DBG_PFX "Too long record to be written\n");
+               return -EINVAL;
+       }
+
+       if (mutex_lock_interruptible(&erst_dbg_mutex))
+               return -EINTR;
+       if (usize > erst_dbg_buf_len) {
+               kfree(erst_dbg_buf);
+               rc = -ENOMEM;
+               erst_dbg_buf = kmalloc(usize, GFP_KERNEL);
+               if (!erst_dbg_buf)
+                       goto out;
+               erst_dbg_buf_len = usize;
+       }
+       rc = copy_from_user(erst_dbg_buf, ubuf, usize);
+       if (rc) {
+               rc = -EFAULT;
+               goto out;
+       }
+       rcd = erst_dbg_buf;
+       rc = -EINVAL;
+       if (rcd->record_length != usize)
+               goto out;
+
+       rc = erst_write(erst_dbg_buf);
+
+out:
+       mutex_unlock(&erst_dbg_mutex);
+       return rc < 0 ? rc : usize;
+}
+
+static const struct file_operations erst_dbg_ops = {
+       .owner          = THIS_MODULE,
+       .open           = erst_dbg_open,
+       .read           = erst_dbg_read,
+       .write          = erst_dbg_write,
+       .unlocked_ioctl = erst_dbg_ioctl,
+};
+
+static struct miscdevice erst_dbg_dev = {
+       .minor  = MISC_DYNAMIC_MINOR,
+       .name   = "erst_dbg",
+       .fops   = &erst_dbg_ops,
+};
+
+static __init int erst_dbg_init(void)
+{
+       return misc_register(&erst_dbg_dev);
+}
+
+static __exit void erst_dbg_exit(void)
+{
+       misc_deregister(&erst_dbg_dev);
+       kfree(erst_dbg_buf);
+}
+
+module_init(erst_dbg_init);
+module_exit(erst_dbg_exit);
+
+MODULE_AUTHOR("Huang Ying");
+MODULE_DESCRIPTION("APEI Error Record Serialization Table debug support");
+MODULE_LICENSE("GPL");
index fd0cc016a0992ec1a5cd498787241e2fd3b36f34..385a6059714a72dd32256685a2606586b92d771e 100644 (file)
@@ -41,6 +41,8 @@
 #include <linux/interrupt.h>
 #include <linux/cper.h>
 #include <linux/kdebug.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
 #include <acpi/apei.h>
 #include <acpi/atomicio.h>
 #include <acpi/hed.h>
@@ -87,6 +89,7 @@ struct ghes {
  * used for that.
  */
 static LIST_HEAD(ghes_sci);
+static DEFINE_MUTEX(ghes_list_mutex);
 
 static struct ghes *ghes_new(struct acpi_hest_generic *generic)
 {
@@ -132,26 +135,26 @@ static void ghes_fini(struct ghes *ghes)
 }
 
 enum {
-       GHES_SER_NO = 0x0,
-       GHES_SER_CORRECTED = 0x1,
-       GHES_SER_RECOVERABLE = 0x2,
-       GHES_SER_PANIC = 0x3,
+       GHES_SEV_NO = 0x0,
+       GHES_SEV_CORRECTED = 0x1,
+       GHES_SEV_RECOVERABLE = 0x2,
+       GHES_SEV_PANIC = 0x3,
 };
 
 static inline int ghes_severity(int severity)
 {
        switch (severity) {
-       case CPER_SER_INFORMATIONAL:
-               return GHES_SER_NO;
-       case CPER_SER_CORRECTED:
-               return GHES_SER_CORRECTED;
-       case CPER_SER_RECOVERABLE:
-               return GHES_SER_RECOVERABLE;
-       case CPER_SER_FATAL:
-               return GHES_SER_PANIC;
+       case CPER_SEV_INFORMATIONAL:
+               return GHES_SEV_NO;
+       case CPER_SEV_CORRECTED:
+               return GHES_SEV_CORRECTED;
+       case CPER_SEV_RECOVERABLE:
+               return GHES_SEV_RECOVERABLE;
+       case CPER_SEV_FATAL:
+               return GHES_SEV_PANIC;
        default:
                /* Unkown, go panic */
-               return GHES_SER_PANIC;
+               return GHES_SEV_PANIC;
        }
 }
 
@@ -237,16 +240,16 @@ static void ghes_clear_estatus(struct ghes *ghes)
 
 static void ghes_do_proc(struct ghes *ghes)
 {
-       int ser, processed = 0;
+       int sev, processed = 0;
        struct acpi_hest_generic_data *gdata;
 
-       ser = ghes_severity(ghes->estatus->error_severity);
+       sev = ghes_severity(ghes->estatus->error_severity);
        apei_estatus_for_each_section(ghes->estatus, gdata) {
 #ifdef CONFIG_X86_MCE
                if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
                                 CPER_SEC_PLATFORM_MEM)) {
                        apei_mce_report_mem_error(
-                               ser == GHES_SER_CORRECTED,
+                               sev == GHES_SEV_CORRECTED,
                                (struct cper_sec_mem_err *)(gdata+1));
                        processed = 1;
                }
@@ -293,18 +296,15 @@ static struct notifier_block ghes_notifier_sci = {
        .notifier_call = ghes_notify_sci,
 };
 
-static int hest_ghes_parse(struct acpi_hest_header *hest_hdr, void *data)
+static int __devinit ghes_probe(struct platform_device *ghes_dev)
 {
        struct acpi_hest_generic *generic;
        struct ghes *ghes = NULL;
-       int rc = 0;
+       int rc = -EINVAL;
 
-       if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
-               return 0;
-
-       generic = (struct acpi_hest_generic *)hest_hdr;
+       generic = ghes_dev->dev.platform_data;
        if (!generic->enabled)
-               return 0;
+               return -ENODEV;
 
        if (generic->error_block_length <
            sizeof(struct acpi_hest_generic_status)) {
@@ -327,62 +327,91 @@ static int hest_ghes_parse(struct acpi_hest_header *hest_hdr, void *data)
                ghes = NULL;
                goto err;
        }
-       switch (generic->notify.type) {
-       case ACPI_HEST_NOTIFY_POLLED:
-               pr_warning(GHES_PFX
-"Generic hardware error source: %d notified via POLL is not supported!\n",
-                          generic->header.source_id);
-               break;
-       case ACPI_HEST_NOTIFY_EXTERNAL:
-       case ACPI_HEST_NOTIFY_LOCAL:
-               pr_warning(GHES_PFX
-"Generic hardware error source: %d notified via IRQ is not supported!\n",
-                          generic->header.source_id);
-               break;
-       case ACPI_HEST_NOTIFY_SCI:
+       if (generic->notify.type == ACPI_HEST_NOTIFY_SCI) {
+               mutex_lock(&ghes_list_mutex);
                if (list_empty(&ghes_sci))
                        register_acpi_hed_notifier(&ghes_notifier_sci);
                list_add_rcu(&ghes->list, &ghes_sci);
-               break;
-       case ACPI_HEST_NOTIFY_NMI:
-               pr_warning(GHES_PFX
-"Generic hardware error source: %d notified via NMI is not supported!\n",
-                          generic->header.source_id);
-               break;
-       default:
-               pr_warning(FW_WARN GHES_PFX
-       "Unknown notification type: %u for generic hardware error source: %d\n",
-                          generic->notify.type, generic->header.source_id);
-               break;
+               mutex_unlock(&ghes_list_mutex);
+       } else {
+               unsigned char *notify = NULL;
+
+               switch (generic->notify.type) {
+               case ACPI_HEST_NOTIFY_POLLED:
+                       notify = "POLL";
+                       break;
+               case ACPI_HEST_NOTIFY_EXTERNAL:
+               case ACPI_HEST_NOTIFY_LOCAL:
+                       notify = "IRQ";
+                       break;
+               case ACPI_HEST_NOTIFY_NMI:
+                       notify = "NMI";
+                       break;
+               }
+               if (notify) {
+                       pr_warning(GHES_PFX
+"Generic hardware error source: %d notified via %s is not supported!\n",
+                                  generic->header.source_id, notify);
+               } else {
+                       pr_warning(FW_WARN GHES_PFX
+"Unknown notification type: %u for generic hardware error source: %d\n",
+                       generic->notify.type, generic->header.source_id);
+               }
+               rc = -ENODEV;
+               goto err;
        }
+       platform_set_drvdata(ghes_dev, ghes);
 
        return 0;
 err:
-       if (ghes)
+       if (ghes) {
                ghes_fini(ghes);
+               kfree(ghes);
+       }
        return rc;
 }
 
-static void ghes_cleanup(void)
+static int __devexit ghes_remove(struct platform_device *ghes_dev)
 {
-       struct ghes *ghes, *nghes;
+       struct ghes *ghes;
+       struct acpi_hest_generic *generic;
 
-       if (!list_empty(&ghes_sci))
-               unregister_acpi_hed_notifier(&ghes_notifier_sci);
+       ghes = platform_get_drvdata(ghes_dev);
+       generic = ghes->generic;
+
+       switch (generic->notify.type) {
+       case ACPI_HEST_NOTIFY_SCI:
+               mutex_lock(&ghes_list_mutex);
+               list_del_rcu(&ghes->list);
+               if (list_empty(&ghes_sci))
+                       unregister_acpi_hed_notifier(&ghes_notifier_sci);
+               mutex_unlock(&ghes_list_mutex);
+               break;
+       default:
+               BUG();
+               break;
+       }
 
        synchronize_rcu();
+       ghes_fini(ghes);
+       kfree(ghes);
 
-       list_for_each_entry_safe(ghes, nghes, &ghes_sci, list) {
-               list_del(&ghes->list);
-               ghes_fini(ghes);
-               kfree(ghes);
-       }
+       platform_set_drvdata(ghes_dev, NULL);
+
+       return 0;
 }
 
+static struct platform_driver ghes_platform_driver = {
+       .driver         = {
+               .name   = "GHES",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = ghes_probe,
+       .remove         = ghes_remove,
+};
+
 static int __init ghes_init(void)
 {
-       int rc;
-
        if (acpi_disabled)
                return -ENODEV;
 
@@ -391,32 +420,12 @@ static int __init ghes_init(void)
                return -EINVAL;
        }
 
-       rc = apei_hest_parse(hest_ghes_parse, NULL);
-       if (rc) {
-               pr_err(GHES_PFX
-               "Error during parsing HEST generic hardware error sources.\n");
-               goto err_cleanup;
-       }
-
-       if (list_empty(&ghes_sci)) {
-               pr_info(GHES_PFX
-                       "No functional generic hardware error sources.\n");
-               rc = -ENODEV;
-               goto err_cleanup;
-       }
-
-       pr_info(GHES_PFX
-               "Generic Hardware Error Source support is initialized.\n");
-
-       return 0;
-err_cleanup:
-       ghes_cleanup();
-       return rc;
+       return platform_driver_register(&ghes_platform_driver);
 }
 
 static void __exit ghes_exit(void)
 {
-       ghes_cleanup();
+       platform_driver_unregister(&ghes_platform_driver);
 }
 
 module_init(ghes_init);
@@ -425,3 +434,4 @@ module_exit(ghes_exit);
 MODULE_AUTHOR("Huang Ying");
 MODULE_DESCRIPTION("APEI Generic Hardware Error Source support");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:GHES");
index e7f40d362cb37c9687602ef4eea1646bfea2f0db..343168d1826626c202171c3a53c5b5e4c2090a65 100644 (file)
@@ -34,6 +34,7 @@
 #include <linux/kdebug.h>
 #include <linux/highmem.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
 #include <acpi/apei.h>
 
 #include "apei-internal.h"
@@ -47,11 +48,6 @@ EXPORT_SYMBOL_GPL(hest_disable);
 
 static struct acpi_table_hest *hest_tab;
 
-static int hest_void_parse(struct acpi_hest_header *hest_hdr, void *data)
-{
-       return 0;
-}
-
 static int hest_esrc_len_tab[ACPI_HEST_TYPE_RESERVED] = {
        [ACPI_HEST_TYPE_IA32_CHECK] = -1,       /* need further calculation */
        [ACPI_HEST_TYPE_IA32_CORRECTED_CHECK] = -1,
@@ -125,6 +121,69 @@ int apei_hest_parse(apei_hest_func_t func, void *data)
 }
 EXPORT_SYMBOL_GPL(apei_hest_parse);
 
+struct ghes_arr {
+       struct platform_device **ghes_devs;
+       unsigned int count;
+};
+
+static int hest_parse_ghes_count(struct acpi_hest_header *hest_hdr, void *data)
+{
+       int *count = data;
+
+       if (hest_hdr->type == ACPI_HEST_TYPE_GENERIC_ERROR)
+               (*count)++;
+       return 0;
+}
+
+static int hest_parse_ghes(struct acpi_hest_header *hest_hdr, void *data)
+{
+       struct acpi_hest_generic *generic;
+       struct platform_device *ghes_dev;
+       struct ghes_arr *ghes_arr = data;
+       int rc;
+
+       if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
+               return 0;
+       generic = (struct acpi_hest_generic *)hest_hdr;
+       if (!generic->enabled)
+               return 0;
+       ghes_dev = platform_device_alloc("GHES", hest_hdr->source_id);
+       if (!ghes_dev)
+               return -ENOMEM;
+       ghes_dev->dev.platform_data = generic;
+       rc = platform_device_add(ghes_dev);
+       if (rc)
+               goto err;
+       ghes_arr->ghes_devs[ghes_arr->count++] = ghes_dev;
+
+       return 0;
+err:
+       platform_device_put(ghes_dev);
+       return rc;
+}
+
+static int hest_ghes_dev_register(unsigned int ghes_count)
+{
+       int rc, i;
+       struct ghes_arr ghes_arr;
+
+       ghes_arr.count = 0;
+       ghes_arr.ghes_devs = kmalloc(sizeof(void *) * ghes_count, GFP_KERNEL);
+       if (!ghes_arr.ghes_devs)
+               return -ENOMEM;
+
+       rc = apei_hest_parse(hest_parse_ghes, &ghes_arr);
+       if (rc)
+               goto err;
+out:
+       kfree(ghes_arr.ghes_devs);
+       return rc;
+err:
+       for (i = 0; i < ghes_arr.count; i++)
+               platform_device_unregister(ghes_arr.ghes_devs[i]);
+       goto out;
+}
+
 static int __init setup_hest_disable(char *str)
 {
        hest_disable = 1;
@@ -137,6 +196,7 @@ static int __init hest_init(void)
 {
        acpi_status status;
        int rc = -ENODEV;
+       unsigned int ghes_count = 0;
 
        if (acpi_disabled)
                goto err;
@@ -158,7 +218,11 @@ static int __init hest_init(void)
                goto err;
        }
 
-       rc = apei_hest_parse(hest_void_parse, NULL);
+       rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
+       if (rc)
+               goto err;
+
+       rc = hest_ghes_dev_register(ghes_count);
        if (rc)
                goto err;
 
index c1d23cd71652baeed8e64f0f39a96693921fe81a..5c221ab535d5b0a459516a16034f80a94a7d1bb4 100644 (file)
@@ -1034,8 +1034,8 @@ static int __init acpi_init(void)
        acpi_scan_init();
        acpi_ec_init();
        acpi_power_init();
-       acpi_system_init();
-       acpi_debug_init();
+       acpi_sysfs_init();
+       acpi_debugfs_init();
        acpi_sleep_proc_init();
        acpi_wakeup_device_init();
        return result;
diff --git a/drivers/acpi/debug.c b/drivers/acpi/debug.c
deleted file mode 100644 (file)
index 295dbfa..0000000
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
- * debug.c - ACPI debug interface to userspace.
- */
-
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/moduleparam.h>
-#include <linux/debugfs.h>
-#include <linux/slab.h>
-#include <asm/uaccess.h>
-#include <acpi/acpi_drivers.h>
-
-#define _COMPONENT             ACPI_SYSTEM_COMPONENT
-ACPI_MODULE_NAME("debug");
-
-struct acpi_dlayer {
-       const char *name;
-       unsigned long value;
-};
-struct acpi_dlevel {
-       const char *name;
-       unsigned long value;
-};
-#define ACPI_DEBUG_INIT(v)     { .name = #v, .value = v }
-
-static const struct acpi_dlayer acpi_debug_layers[] = {
-       ACPI_DEBUG_INIT(ACPI_UTILITIES),
-       ACPI_DEBUG_INIT(ACPI_HARDWARE),
-       ACPI_DEBUG_INIT(ACPI_EVENTS),
-       ACPI_DEBUG_INIT(ACPI_TABLES),
-       ACPI_DEBUG_INIT(ACPI_NAMESPACE),
-       ACPI_DEBUG_INIT(ACPI_PARSER),
-       ACPI_DEBUG_INIT(ACPI_DISPATCHER),
-       ACPI_DEBUG_INIT(ACPI_EXECUTER),
-       ACPI_DEBUG_INIT(ACPI_RESOURCES),
-       ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER),
-       ACPI_DEBUG_INIT(ACPI_OS_SERVICES),
-       ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER),
-       ACPI_DEBUG_INIT(ACPI_COMPILER),
-       ACPI_DEBUG_INIT(ACPI_TOOLS),
-
-       ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_AC_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT),
-       ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT),
-};
-
-static const struct acpi_dlevel acpi_debug_levels[] = {
-       ACPI_DEBUG_INIT(ACPI_LV_INIT),
-       ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT),
-       ACPI_DEBUG_INIT(ACPI_LV_INFO),
-
-       ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES),
-       ACPI_DEBUG_INIT(ACPI_LV_PARSE),
-       ACPI_DEBUG_INIT(ACPI_LV_LOAD),
-       ACPI_DEBUG_INIT(ACPI_LV_DISPATCH),
-       ACPI_DEBUG_INIT(ACPI_LV_EXEC),
-       ACPI_DEBUG_INIT(ACPI_LV_NAMES),
-       ACPI_DEBUG_INIT(ACPI_LV_OPREGION),
-       ACPI_DEBUG_INIT(ACPI_LV_BFIELD),
-       ACPI_DEBUG_INIT(ACPI_LV_TABLES),
-       ACPI_DEBUG_INIT(ACPI_LV_VALUES),
-       ACPI_DEBUG_INIT(ACPI_LV_OBJECTS),
-       ACPI_DEBUG_INIT(ACPI_LV_RESOURCES),
-       ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS),
-       ACPI_DEBUG_INIT(ACPI_LV_PACKAGE),
-
-       ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS),
-       ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS),
-       ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS),
-
-       ACPI_DEBUG_INIT(ACPI_LV_MUTEX),
-       ACPI_DEBUG_INIT(ACPI_LV_THREADS),
-       ACPI_DEBUG_INIT(ACPI_LV_IO),
-       ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS),
-
-       ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE),
-       ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO),
-       ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES),
-       ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
-};
-
-/* --------------------------------------------------------------------------
-                              FS Interface (/sys)
-   -------------------------------------------------------------------------- */
-static int param_get_debug_layer(char *buffer, const struct kernel_param *kp)
-{
-       int result = 0;
-       int i;
-
-       result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
-
-       for(i = 0; i <ARRAY_SIZE(acpi_debug_layers); i++) {
-               result += sprintf(buffer+result, "%-25s\t0x%08lX [%c]\n",
-                                       acpi_debug_layers[i].name,
-                                       acpi_debug_layers[i].value,
-                                       (acpi_dbg_layer & acpi_debug_layers[i].value) ? '*' : ' ');
-       }
-       result += sprintf(buffer+result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
-                                       ACPI_ALL_DRIVERS,
-                                       (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
-                                       ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer &
-                                       ACPI_ALL_DRIVERS) == 0 ? ' ' : '-');
-       result += sprintf(buffer+result, "--\ndebug_layer = 0x%08X ( * = enabled)\n", acpi_dbg_layer);
-
-       return result;
-}
-
-static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
-{
-       int result = 0;
-       int i;
-
-       result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
-
-       for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
-               result += sprintf(buffer+result, "%-25s\t0x%08lX [%c]\n",
-                                    acpi_debug_levels[i].name,
-                                    acpi_debug_levels[i].value,
-                                    (acpi_dbg_level & acpi_debug_levels[i].
-                                     value) ? '*' : ' ');
-       }
-       result += sprintf(buffer+result, "--\ndebug_level = 0x%08X (* = enabled)\n",
-                            acpi_dbg_level);
-
-       return result;
-}
-
-static struct kernel_param_ops acpi_debug_layer_ops = {
-       .set = param_set_uint,
-       .get = param_get_debug_layer,
-};
-
-static struct kernel_param_ops acpi_debug_level_ops = {
-       .set = param_set_uint,
-       .get = param_get_debug_level,
-};
-
-module_param_cb(debug_layer, &acpi_debug_layer_ops, &acpi_dbg_layer, 0644);
-module_param_cb(debug_level, &acpi_debug_level_ops, &acpi_dbg_level, 0644);
-
-static char trace_method_name[6];
-module_param_string(trace_method_name, trace_method_name, 6, 0644);
-static unsigned int trace_debug_layer;
-module_param(trace_debug_layer, uint, 0644);
-static unsigned int trace_debug_level;
-module_param(trace_debug_level, uint, 0644);
-
-static int param_set_trace_state(const char *val, const struct kernel_param *kp)
-{
-       int result = 0;
-
-       if (!strncmp(val, "enable", strlen("enable") - 1)) {
-               result = acpi_debug_trace(trace_method_name, trace_debug_level,
-                                         trace_debug_layer, 0);
-               if (result)
-                       result = -EBUSY;
-               goto exit;
-       }
-
-       if (!strncmp(val, "disable", strlen("disable") - 1)) {
-               int name = 0;
-               result = acpi_debug_trace((char *)&name, trace_debug_level,
-                                         trace_debug_layer, 0);
-               if (result)
-                       result = -EBUSY;
-               goto exit;
-       }
-
-       if (!strncmp(val, "1", 1)) {
-               result = acpi_debug_trace(trace_method_name, trace_debug_level,
-                                         trace_debug_layer, 1);
-               if (result)
-                       result = -EBUSY;
-               goto exit;
-       }
-
-       result = -EINVAL;
-exit:
-       return result;
-}
-
-static int param_get_trace_state(char *buffer, const struct kernel_param *kp)
-{
-       if (!acpi_gbl_trace_method_name)
-               return sprintf(buffer, "disable");
-       else {
-               if (acpi_gbl_trace_flags & 1)
-                       return sprintf(buffer, "1");
-               else
-                       return sprintf(buffer, "enable");
-       }
-       return 0;
-}
-
-static struct kernel_param_ops param_ops_trace_state = {
-       .set = param_set_trace_state,
-       .get = param_get_trace_state,
-};
-
-module_param_cb(trace_state, &param_ops_trace_state, NULL, 0644);
-
-/* --------------------------------------------------------------------------
-                               DebugFS Interface
-   -------------------------------------------------------------------------- */
-
-static ssize_t cm_write(struct file *file, const char __user *user_buf,
-                       size_t count, loff_t *ppos)
-{
-       static char *buf;
-       static int uncopied_bytes;
-       struct acpi_table_header table;
-       acpi_status status;
-
-       if (!(*ppos)) {
-               /* parse the table header to get the table length */
-               if (count <= sizeof(struct acpi_table_header))
-                       return -EINVAL;
-               if (copy_from_user(&table, user_buf,
-                       sizeof(struct acpi_table_header)))
-                       return -EFAULT;
-               uncopied_bytes = table.length;
-               buf = kzalloc(uncopied_bytes, GFP_KERNEL);
-               if (!buf)
-                       return -ENOMEM;
-       }
-
-       if (uncopied_bytes < count) {
-               kfree(buf);
-               return -EINVAL;
-       }
-
-       if (copy_from_user(buf + (*ppos), user_buf, count)) {
-               kfree(buf);
-               return -EFAULT;
-       }
-
-       uncopied_bytes -= count;
-       *ppos += count;
-
-       if (!uncopied_bytes) {
-               status = acpi_install_method(buf);
-               kfree(buf);
-               if (ACPI_FAILURE(status))
-                       return -EINVAL;
-               add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
-       }
-
-       return count;
-}
-
-static const struct file_operations cm_fops = {
-       .write = cm_write,
-};
-
-static int acpi_debugfs_init(void)
-{
-       struct dentry *acpi_dir, *cm_dentry;
-
-       acpi_dir = debugfs_create_dir("acpi", NULL);
-       if (!acpi_dir)
-               goto err;
-
-       cm_dentry = debugfs_create_file("custom_method", S_IWUGO,
-                                       acpi_dir, NULL, &cm_fops);
-       if (!cm_dentry)
-               goto err;
-
-       return 0;
-
-err:
-       if (acpi_dir)
-               debugfs_remove(acpi_dir);
-       return -EINVAL;
-}
-
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-#ifdef CONFIG_ACPI_PROCFS
-#define ACPI_SYSTEM_FILE_DEBUG_LAYER   "debug_layer"
-#define ACPI_SYSTEM_FILE_DEBUG_LEVEL           "debug_level"
-
-static int acpi_system_debug_proc_show(struct seq_file *m, void *v)
-{
-       unsigned int i;
-
-       seq_printf(m, "%-25s\tHex        SET\n", "Description");
-
-       switch ((unsigned long)m->private) {
-       case 0:
-               for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
-                       seq_printf(m, "%-25s\t0x%08lX [%c]\n",
-                                    acpi_debug_layers[i].name,
-                                    acpi_debug_layers[i].value,
-                                    (acpi_dbg_layer & acpi_debug_layers[i].
-                                     value) ? '*' : ' ');
-               }
-               seq_printf(m, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
-                            ACPI_ALL_DRIVERS,
-                            (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
-                            ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer &
-                                                      ACPI_ALL_DRIVERS) ==
-                            0 ? ' ' : '-');
-               seq_printf(m,
-                            "--\ndebug_layer = 0x%08X (* = enabled, - = partial)\n",
-                            acpi_dbg_layer);
-               break;
-       case 1:
-               for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
-                       seq_printf(m, "%-25s\t0x%08lX [%c]\n",
-                                    acpi_debug_levels[i].name,
-                                    acpi_debug_levels[i].value,
-                                    (acpi_dbg_level & acpi_debug_levels[i].
-                                     value) ? '*' : ' ');
-               }
-               seq_printf(m, "--\ndebug_level = 0x%08X (* = enabled)\n",
-                            acpi_dbg_level);
-               break;
-       }
-       return 0;
-}
-
-static int acpi_system_debug_proc_open(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_system_debug_proc_show, PDE(inode)->data);
-}
-
-static ssize_t acpi_system_debug_proc_write(struct file *file,
-                       const char __user * buffer,
-                       size_t count, loff_t *pos)
-{
-       char debug_string[12] = { '\0' };
-
-
-       if (count > sizeof(debug_string) - 1)
-               return -EINVAL;
-
-       if (copy_from_user(debug_string, buffer, count))
-               return -EFAULT;
-
-       debug_string[count] = '\0';
-
-       switch ((unsigned long)PDE(file->f_path.dentry->d_inode)->data) {
-       case 0:
-               acpi_dbg_layer = simple_strtoul(debug_string, NULL, 0);
-               break;
-       case 1:
-               acpi_dbg_level = simple_strtoul(debug_string, NULL, 0);
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       return count;
-}
-
-static const struct file_operations acpi_system_debug_proc_fops = {
-       .owner          = THIS_MODULE,
-       .open           = acpi_system_debug_proc_open,
-       .read           = seq_read,
-       .llseek         = seq_lseek,
-       .release        = single_release,
-       .write          = acpi_system_debug_proc_write,
-};
-#endif
-
-int __init acpi_procfs_init(void)
-{
-#ifdef CONFIG_ACPI_PROCFS
-       struct proc_dir_entry *entry;
-       int error = 0;
-       char *name;
-
-       /* 'debug_layer' [R/W] */
-       name = ACPI_SYSTEM_FILE_DEBUG_LAYER;
-       entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR,
-                                acpi_root_dir, &acpi_system_debug_proc_fops,
-                                (void *)0);
-       if (!entry)
-               goto Error;
-
-       /* 'debug_level' [R/W] */
-       name = ACPI_SYSTEM_FILE_DEBUG_LEVEL;
-       entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR,
-                                acpi_root_dir, &acpi_system_debug_proc_fops,
-                                (void *)1);
-       if (!entry)
-               goto Error;
-
-      Done:
-       return error;
-
-      Error:
-       remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LEVEL, acpi_root_dir);
-       remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LAYER, acpi_root_dir);
-       error = -ENODEV;
-       goto Done;
-#else
-       return 0;
-#endif
-}
-
-int __init acpi_debug_init(void)
-{
-       acpi_debugfs_init();
-       acpi_procfs_init();
-       return 0;
-}
diff --git a/drivers/acpi/debugfs.c b/drivers/acpi/debugfs.c
new file mode 100644 (file)
index 0000000..7de27d4
--- /dev/null
@@ -0,0 +1,93 @@
+/*
+ * debugfs.c - ACPI debugfs interface to userspace.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <acpi/acpi_drivers.h>
+
+#define _COMPONENT             ACPI_SYSTEM_COMPONENT
+ACPI_MODULE_NAME("debugfs");
+
+
+/* /sys/modules/acpi/parameters/aml_debug_output */
+
+module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
+                  bool, 0644);
+MODULE_PARM_DESC(aml_debug_output,
+                "To enable/disable the ACPI Debug Object output.");
+
+/* /sys/kernel/debug/acpi/custom_method */
+
+static ssize_t cm_write(struct file *file, const char __user * user_buf,
+                       size_t count, loff_t *ppos)
+{
+       static char *buf;
+       static int uncopied_bytes;
+       struct acpi_table_header table;
+       acpi_status status;
+
+       if (!(*ppos)) {
+               /* parse the table header to get the table length */
+               if (count <= sizeof(struct acpi_table_header))
+                       return -EINVAL;
+               if (copy_from_user(&table, user_buf,
+                                  sizeof(struct acpi_table_header)))
+                       return -EFAULT;
+               uncopied_bytes = table.length;
+               buf = kzalloc(uncopied_bytes, GFP_KERNEL);
+               if (!buf)
+                       return -ENOMEM;
+       }
+
+       if (uncopied_bytes < count) {
+               kfree(buf);
+               return -EINVAL;
+       }
+
+       if (copy_from_user(buf + (*ppos), user_buf, count)) {
+               kfree(buf);
+               return -EFAULT;
+       }
+
+       uncopied_bytes -= count;
+       *ppos += count;
+
+       if (!uncopied_bytes) {
+               status = acpi_install_method(buf);
+               kfree(buf);
+               if (ACPI_FAILURE(status))
+                       return -EINVAL;
+               add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
+       }
+
+       return count;
+}
+
+static const struct file_operations cm_fops = {
+       .write = cm_write,
+};
+
+int __init acpi_debugfs_init(void)
+{
+       struct dentry *acpi_dir, *cm_dentry;
+
+       acpi_dir = debugfs_create_dir("acpi", NULL);
+       if (!acpi_dir)
+               goto err;
+
+       cm_dentry = debugfs_create_file("custom_method", S_IWUGO,
+                                       acpi_dir, NULL, &cm_fops);
+       if (!cm_dentry)
+               goto err;
+
+       return 0;
+
+err:
+       if (acpi_dir)
+               debugfs_remove(acpi_dir);
+       return -EINVAL;
+}
index 4af6301601e701e1ad0938e47eb65df8400faa4d..78b0164c35b2ccaa25647e9ea0397a249d51656b 100644 (file)
@@ -100,7 +100,8 @@ do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
 
        status = acpi_get_object_info(handle, &info);
        if (ACPI_SUCCESS(status)) {
-               if (info->address == find->address)
+               if ((info->address == find->address)
+                       && (info->valid & ACPI_VALID_ADR))
                        find->handle = handle;
                kfree(info);
        }
index 8ae27264a00e88364f45ae55e9d754ed3dbdc074..a212bfeddf8c0247e2ccfd9a34da8df325bc6576 100644 (file)
 
 int init_acpi_device_notify(void);
 int acpi_scan_init(void);
-int acpi_system_init(void);
+int acpi_sysfs_init(void);
 
-#ifdef CONFIG_ACPI_DEBUG
-int acpi_debug_init(void);
+#ifdef CONFIG_DEBUG_FS
+int acpi_debugfs_init(void);
 #else
-static inline int acpi_debug_init(void) { return 0; }
+static inline int acpi_debugfs_init(void) { return 0; }
 #endif
 
 /* --------------------------------------------------------------------------
index b0337d3146047d150c8a62eb8e5756282e5ea5f0..5718566e00f9b27573db228ba74559570ba48f89 100644 (file)
@@ -255,12 +255,10 @@ acpi_parse_memory_affinity(struct acpi_subtable_header * header,
 
 static int __init acpi_parse_srat(struct acpi_table_header *table)
 {
-       struct acpi_table_srat *srat;
-
        if (!table)
                return -EINVAL;
 
-       srat = (struct acpi_table_srat *)table;
+       /* Real work done in acpi_table_parse_srat below. */
 
        return 0;
 }
index f14d3f251d26107a9905bb5cc1acff04873addef..65b25a303b86e495d3f539e94d6a912ae3252325 100644 (file)
@@ -141,15 +141,14 @@ static struct osi_linux {
 static void __init acpi_request_region (struct acpi_generic_address *addr,
        unsigned int length, char *desc)
 {
-       struct resource *res;
-
        if (!addr->address || !length)
                return;
 
+       /* Resources are never freed */
        if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
-               res = request_region(addr->address, length, desc);
+               request_region(addr->address, length, desc);
        else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
-               res = request_mem_region(addr->address, length, desc);
+               request_mem_region(addr->address, length, desc);
 }
 
 static int __init acpi_reserve_resources(void)
index f74d3b31e5c973cf61b98dbd985611be5fe7eec9..844c155aeb0faa558b789fa7a3b680971df8f536 100644 (file)
@@ -40,8 +40,6 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/slab.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 #include "sleep.h"
@@ -64,7 +62,6 @@ module_param_named(power_nocheck, acpi_power_nocheck, bool, 000);
 static int acpi_power_add(struct acpi_device *device);
 static int acpi_power_remove(struct acpi_device *device, int type);
 static int acpi_power_resume(struct acpi_device *device);
-static int acpi_power_open_fs(struct inode *inode, struct file *file);
 
 static const struct acpi_device_id power_device_ids[] = {
        {ACPI_POWER_HID, 0},
@@ -99,14 +96,6 @@ struct acpi_power_resource {
 
 static struct list_head acpi_power_resource_list;
 
-static const struct file_operations acpi_power_fops = {
-       .owner = THIS_MODULE,
-       .open = acpi_power_open_fs,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-
 /* --------------------------------------------------------------------------
                              Power Resource Management
    -------------------------------------------------------------------------- */
@@ -255,7 +244,6 @@ static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
        struct list_head *node, *next;
        struct acpi_power_reference *ref;
 
-
        result = acpi_power_get_context(handle, &resource);
        if (result)
                return result;
@@ -541,102 +529,6 @@ int acpi_power_transition(struct acpi_device *device, int state)
        return result;
 }
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-
-static struct proc_dir_entry *acpi_power_dir;
-
-static int acpi_power_seq_show(struct seq_file *seq, void *offset)
-{
-       int count = 0;
-       int result = 0, state;
-       struct acpi_power_resource *resource = NULL;
-       struct list_head *node, *next;
-       struct acpi_power_reference *ref;
-
-
-       resource = seq->private;
-
-       if (!resource)
-               goto end;
-
-       result = acpi_power_get_state(resource->device->handle, &state);
-       if (result)
-               goto end;
-
-       seq_puts(seq, "state:                   ");
-       switch (state) {
-       case ACPI_POWER_RESOURCE_STATE_ON:
-               seq_puts(seq, "on\n");
-               break;
-       case ACPI_POWER_RESOURCE_STATE_OFF:
-               seq_puts(seq, "off\n");
-               break;
-       default:
-               seq_puts(seq, "unknown\n");
-               break;
-       }
-
-       mutex_lock(&resource->resource_lock);
-       list_for_each_safe(node, next, &resource->reference) {
-               ref = container_of(node, struct acpi_power_reference, node);
-               count++;
-       }
-       mutex_unlock(&resource->resource_lock);
-
-       seq_printf(seq, "system level:            S%d\n"
-                  "order:                   %d\n"
-                  "reference count:         %d\n",
-                  resource->system_level,
-                  resource->order, count);
-
-      end:
-       return 0;
-}
-
-static int acpi_power_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_power_seq_show, PDE(inode)->data);
-}
-
-static int acpi_power_add_fs(struct acpi_device *device)
-{
-       struct proc_dir_entry *entry = NULL;
-
-
-       if (!device)
-               return -EINVAL;
-
-       if (!acpi_device_dir(device)) {
-               acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
-                                                    acpi_power_dir);
-               if (!acpi_device_dir(device))
-                       return -ENODEV;
-       }
-
-       /* 'status' [R] */
-       entry = proc_create_data(ACPI_POWER_FILE_STATUS,
-                                S_IRUGO, acpi_device_dir(device),
-                                &acpi_power_fops, acpi_driver_data(device));
-       if (!entry)
-               return -EIO;
-       return 0;
-}
-
-static int acpi_power_remove_fs(struct acpi_device *device)
-{
-
-       if (acpi_device_dir(device)) {
-               remove_proc_entry(ACPI_POWER_FILE_STATUS,
-                                 acpi_device_dir(device));
-               remove_proc_entry(acpi_device_bid(device), acpi_power_dir);
-               acpi_device_dir(device) = NULL;
-       }
-
-       return 0;
-}
-
 /* --------------------------------------------------------------------------
                                 Driver Interface
    -------------------------------------------------------------------------- */
@@ -690,10 +582,6 @@ static int acpi_power_add(struct acpi_device *device)
                break;
        }
 
-       result = acpi_power_add_fs(device);
-       if (result)
-               goto end;
-
        printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
               acpi_device_bid(device), state ? "on" : "off");
 
@@ -715,8 +603,6 @@ static int acpi_power_remove(struct acpi_device *device, int type)
 
        resource = acpi_driver_data(device);
 
-       acpi_power_remove_fs(device);
-
        mutex_lock(&resource->resource_lock);
        list_for_each_safe(node, next, &resource->reference) {
                struct acpi_power_reference *ref = container_of(node, struct acpi_power_reference, node);
@@ -760,19 +646,6 @@ static int acpi_power_resume(struct acpi_device *device)
 
 int __init acpi_power_init(void)
 {
-       int result = 0;
-
        INIT_LIST_HEAD(&acpi_power_resource_list);
-
-       acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
-       if (!acpi_power_dir)
-               return -ENODEV;
-
-       result = acpi_bus_register_driver(&acpi_power_driver);
-       if (result < 0) {
-               remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
-               return -ENODEV;
-       }
-
-       return 0;
+       return acpi_bus_register_driver(&acpi_power_driver);
 }
index 1ac678d2c51c691f2431882283b005578f8578bb..afad67769db6216352348ecb207112f13180e862 100644 (file)
 
 /*
  * this file provides support for:
- * /proc/acpi/sleep
  * /proc/acpi/alarm
  * /proc/acpi/wakeup
  */
 
 ACPI_MODULE_NAME("sleep")
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_system_sleep_seq_show(struct seq_file *seq, void *offset)
-{
-       int i;
-
-       for (i = 0; i <= ACPI_STATE_S5; i++) {
-               if (sleep_states[i]) {
-                       seq_printf(seq, "S%d ", i);
-               }
-       }
-
-       seq_puts(seq, "\n");
-
-       return 0;
-}
-
-static int acpi_system_sleep_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_system_sleep_seq_show, PDE(inode)->data);
-}
-
-static ssize_t
-acpi_system_write_sleep(struct file *file,
-                       const char __user * buffer, size_t count, loff_t * ppos)
-{
-       char str[12];
-       u32 state = 0;
-       int error = 0;
-
-       if (count > sizeof(str) - 1)
-               goto Done;
-       memset(str, 0, sizeof(str));
-       if (copy_from_user(str, buffer, count))
-               return -EFAULT;
-
-       /* Check for S4 bios request */
-       if (!strcmp(str, "4b")) {
-               error = acpi_suspend(4);
-               goto Done;
-       }
-       state = simple_strtoul(str, NULL, 0);
-#ifdef CONFIG_HIBERNATION
-       if (state == 4) {
-               error = hibernate();
-               goto Done;
-       }
-#endif
-       error = acpi_suspend(state);
-      Done:
-       return error ? error : count;
-}
-#endif                         /* CONFIG_ACPI_PROCFS */
 
 #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE) || !defined(CONFIG_X86)
 /* use /sys/class/rtc/rtcX/wakealarm instead; it's not ACPI-specific */
@@ -463,17 +410,6 @@ static const struct file_operations acpi_system_wakeup_device_fops = {
        .release = single_release,
 };
 
-#ifdef CONFIG_ACPI_PROCFS
-static const struct file_operations acpi_system_sleep_fops = {
-       .owner = THIS_MODULE,
-       .open = acpi_system_sleep_open_fs,
-       .read = seq_read,
-       .write = acpi_system_write_sleep,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-#endif                         /* CONFIG_ACPI_PROCFS */
-
 #ifdef HAVE_ACPI_LEGACY_ALARM
 static const struct file_operations acpi_system_alarm_fops = {
        .owner = THIS_MODULE,
@@ -495,12 +431,6 @@ static u32 rtc_handler(void *context)
 
 int __init acpi_sleep_proc_init(void)
 {
-#ifdef CONFIG_ACPI_PROCFS
-       /* 'sleep' [R/W] */
-       proc_create("sleep", S_IFREG | S_IRUGO | S_IWUSR,
-                   acpi_root_dir, &acpi_system_sleep_fops);
-#endif                         /* CONFIG_ACPI_PROCFS */
-
 #ifdef HAVE_ACPI_LEGACY_ALARM
        /* 'alarm' [R/W] */
        proc_create("alarm", S_IFREG | S_IRUGO | S_IWUSR,
index 38ea0cc6dc49aba88b53a503107d144fcebe992b..15602189238942cc9db03b9d9f25c18823128ea0 100644 (file)
@@ -83,9 +83,6 @@ MODULE_LICENSE("GPL");
 
 static int acpi_processor_add(struct acpi_device *device);
 static int acpi_processor_remove(struct acpi_device *device, int type);
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
-#endif
 static void acpi_processor_notify(struct acpi_device *device, u32 event);
 static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
 static int acpi_processor_handle_eject(struct acpi_processor *pr);
@@ -113,15 +110,6 @@ static struct acpi_driver acpi_processor_driver = {
 
 #define INSTALL_NOTIFY_HANDLER         1
 #define UNINSTALL_NOTIFY_HANDLER       2
-#ifdef CONFIG_ACPI_PROCFS
-static const struct file_operations acpi_processor_info_fops = {
-       .owner = THIS_MODULE,
-       .open = acpi_processor_info_open_fs,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-#endif
 
 DEFINE_PER_CPU(struct acpi_processor *, processors);
 EXPORT_PER_CPU_SYMBOL(processors);
@@ -256,44 +244,8 @@ static int acpi_processor_errata(struct acpi_processor *pr)
        return result;
 }
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-
-#ifdef CONFIG_ACPI_PROCFS
 static struct proc_dir_entry *acpi_processor_dir = NULL;
 
-static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
-{
-       struct acpi_processor *pr = seq->private;
-
-
-       if (!pr)
-               goto end;
-
-       seq_printf(seq, "processor id:            %d\n"
-                  "acpi id:                 %d\n"
-                  "bus mastering control:   %s\n"
-                  "power management:        %s\n"
-                  "throttling control:      %s\n"
-                  "limit interface:         %s\n",
-                  pr->id,
-                  pr->acpi_id,
-                  pr->flags.bm_control ? "yes" : "no",
-                  pr->flags.power ? "yes" : "no",
-                  pr->flags.throttling ? "yes" : "no",
-                  pr->flags.limit ? "yes" : "no");
-
-      end:
-       return 0;
-}
-
-static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_processor_info_seq_show,
-                          PDE(inode)->data);
-}
-
 static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
 {
        struct proc_dir_entry *entry = NULL;
@@ -306,14 +258,6 @@ static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
                        return -ENODEV;
        }
 
-       /* 'info' [R] */
-       entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO,
-                                S_IRUGO, acpi_device_dir(device),
-                                &acpi_processor_info_fops,
-                                acpi_driver_data(device));
-       if (!entry)
-               return -EIO;
-
        /* 'throttling' [R/W] */
        entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING,
                                 S_IFREG | S_IRUGO | S_IWUSR,
@@ -322,43 +266,20 @@ static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
                                 acpi_driver_data(device));
        if (!entry)
                return -EIO;
-
-       /* 'limit' [R/W] */
-       entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT,
-                                S_IFREG | S_IRUGO | S_IWUSR,
-                                acpi_device_dir(device),
-                                &acpi_processor_limit_fops,
-                                acpi_driver_data(device));
-       if (!entry)
-               return -EIO;
        return 0;
 }
 static int acpi_processor_remove_fs(struct acpi_device *device)
 {
 
        if (acpi_device_dir(device)) {
-               remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
-                                 acpi_device_dir(device));
                remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
                                  acpi_device_dir(device));
-               remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
-                                 acpi_device_dir(device));
                remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
                acpi_device_dir(device) = NULL;
        }
 
        return 0;
 }
-#else
-static inline int acpi_processor_add_fs(struct acpi_device *device)
-{
-       return 0;
-}
-static inline int acpi_processor_remove_fs(struct acpi_device *device)
-{
-       return 0;
-}
-#endif
 
 /* --------------------------------------------------------------------------
                                  Driver Interface
@@ -921,11 +842,9 @@ static int __init acpi_processor_init(void)
 
        memset(&errata, 0, sizeof(errata));
 
-#ifdef CONFIG_ACPI_PROCFS
        acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
        if (!acpi_processor_dir)
                return -ENOMEM;
-#endif
 
        if (!cpuidle_register_driver(&acpi_idle_driver)) {
                printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
@@ -952,9 +871,7 @@ static int __init acpi_processor_init(void)
 out_cpuidle:
        cpuidle_unregister_driver(&acpi_idle_driver);
 
-#ifdef CONFIG_ACPI_PROCFS
        remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
-#endif
 
        return result;
 }
@@ -974,9 +891,7 @@ static void __exit acpi_processor_exit(void)
 
        cpuidle_unregister_driver(&acpi_idle_driver);
 
-#ifdef CONFIG_ACPI_PROCFS
        remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
-#endif
 
        return;
 }
index b4c2f3bdadebc9ad6b23ce3ea1d2a8114b5c022f..f4428e82b352940f7b9f8687c3c242b213d48421 100644 (file)
@@ -33,8 +33,6 @@
 #include <linux/init.h>
 #include <linux/cpufreq.h>
 #include <linux/slab.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include <linux/moduleparam.h>
@@ -82,13 +80,6 @@ module_param(bm_check_disable, uint, 0000);
 static unsigned int latency_factor __read_mostly = 2;
 module_param(latency_factor, uint, 0644);
 
-#ifdef CONFIG_ACPI_PROCFS
-static u64 us_to_pm_timer_ticks(s64 t)
-{
-       return div64_u64(t * PM_TIMER_FREQUENCY, 1000000);
-}
-#endif
-
 /*
  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
  * For now disable this. Probably a bug somewhere else.
@@ -689,78 +680,6 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
        return 0;
 }
 
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
-{
-       struct acpi_processor *pr = seq->private;
-       unsigned int i;
-
-
-       if (!pr)
-               goto end;
-
-       seq_printf(seq, "active state:            C%zd\n"
-                  "max_cstate:              C%d\n"
-                  "maximum allowed latency: %d usec\n",
-                  pr->power.state ? pr->power.state - pr->power.states : 0,
-                  max_cstate, pm_qos_request(PM_QOS_CPU_DMA_LATENCY));
-
-       seq_puts(seq, "states:\n");
-
-       for (i = 1; i <= pr->power.count; i++) {
-               seq_printf(seq, "   %cC%d:                  ",
-                          (&pr->power.states[i] ==
-                           pr->power.state ? '*' : ' '), i);
-
-               if (!pr->power.states[i].valid) {
-                       seq_puts(seq, "<not supported>\n");
-                       continue;
-               }
-
-               switch (pr->power.states[i].type) {
-               case ACPI_STATE_C1:
-                       seq_printf(seq, "type[C1] ");
-                       break;
-               case ACPI_STATE_C2:
-                       seq_printf(seq, "type[C2] ");
-                       break;
-               case ACPI_STATE_C3:
-                       seq_printf(seq, "type[C3] ");
-                       break;
-               default:
-                       seq_printf(seq, "type[--] ");
-                       break;
-               }
-
-               seq_puts(seq, "promotion[--] ");
-
-               seq_puts(seq, "demotion[--] ");
-
-               seq_printf(seq, "latency[%03d] usage[%08d] duration[%020Lu]\n",
-                          pr->power.states[i].latency,
-                          pr->power.states[i].usage,
-                          us_to_pm_timer_ticks(pr->power.states[i].time));
-       }
-
-      end:
-       return 0;
-}
-
-static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_processor_power_seq_show,
-                          PDE(inode)->data);
-}
-
-static const struct file_operations acpi_processor_power_fops = {
-       .owner = THIS_MODULE,
-       .open = acpi_processor_power_open_fs,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-#endif
-
 /**
  * acpi_idle_bm_check - checks if bus master activity was detected
  */
@@ -803,13 +722,12 @@ static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
        } else if (cx->entry_method == ACPI_CSTATE_HALT) {
                acpi_safe_halt();
        } else {
-               int unused;
                /* IO port based C-state */
                inb(cx->address);
                /* Dummy wait op - must do something useless after P_LVL2 read
                   because chipsets cannot guarantee that STPCLK# signal
                   gets asserted in time to freeze execution properly. */
-               unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
+               inl(acpi_gbl_FADT.xpm_timer_block.address);
        }
        start_critical_timings();
 }
@@ -1172,9 +1090,6 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
 {
        acpi_status status = 0;
        static int first_run;
-#ifdef CONFIG_ACPI_PROCFS
-       struct proc_dir_entry *entry = NULL;
-#endif
 
        if (boot_option_idle_override)
                return 0;
@@ -1223,15 +1138,6 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
                if (cpuidle_register_device(&pr->power.dev))
                        return -EIO;
        }
-#ifdef CONFIG_ACPI_PROCFS
-       /* 'power' [R] */
-       entry = proc_create_data(ACPI_PROCESSOR_FILE_POWER,
-                                S_IRUGO, acpi_device_dir(device),
-                                &acpi_processor_power_fops,
-                                acpi_driver_data(device));
-       if (!entry)
-               return -EIO;
-#endif
        return 0;
 }
 
@@ -1244,11 +1150,5 @@ int acpi_processor_power_exit(struct acpi_processor *pr,
        cpuidle_unregister_device(&pr->power.dev);
        pr->flags.power_setup_done = 0;
 
-#ifdef CONFIG_ACPI_PROCFS
-       if (acpi_device_dir(device))
-               remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
-                                 acpi_device_dir(device));
-#endif
-
        return 0;
 }
index 6deafb4aa0da02c44e3e4c1ded6d46c105a22012..953b25fb986968ad47be94d0b8ea000347e4468e 100644 (file)
@@ -30,8 +30,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/cpufreq.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <linux/sysdev.h>
 
 #include <asm/uaccess.h>
@@ -438,84 +436,3 @@ struct thermal_cooling_device_ops processor_cooling_ops = {
        .get_cur_state = processor_get_cur_state,
        .set_cur_state = processor_set_cur_state,
 };
-
-/* /proc interface */
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset)
-{
-       struct acpi_processor *pr = seq->private;
-
-       if (!pr)
-               goto end;
-
-       if (!pr->flags.limit) {
-               seq_puts(seq, "<not supported>\n");
-               goto end;
-       }
-
-       seq_printf(seq, "active limit:            P%d:T%d\n"
-                  "user limit:              P%d:T%d\n"
-                  "thermal limit:           P%d:T%d\n",
-                  pr->limit.state.px, pr->limit.state.tx,
-                  pr->limit.user.px, pr->limit.user.tx,
-                  pr->limit.thermal.px, pr->limit.thermal.tx);
-
-      end:
-       return 0;
-}
-
-static int acpi_processor_limit_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_processor_limit_seq_show,
-                          PDE(inode)->data);
-}
-
-static ssize_t acpi_processor_write_limit(struct file * file,
-                                         const char __user * buffer,
-                                         size_t count, loff_t * data)
-{
-       int result = 0;
-       struct seq_file *m = file->private_data;
-       struct acpi_processor *pr = m->private;
-       char limit_string[25] = { '\0' };
-       int px = 0;
-       int tx = 0;
-
-
-       if (!pr || (count > sizeof(limit_string) - 1)) {
-               return -EINVAL;
-       }
-
-       if (copy_from_user(limit_string, buffer, count)) {
-               return -EFAULT;
-       }
-
-       limit_string[count] = '\0';
-
-       if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) {
-               printk(KERN_ERR PREFIX "Invalid data format\n");
-               return -EINVAL;
-       }
-
-       if (pr->flags.throttling) {
-               if ((tx < 0) || (tx > (pr->throttling.state_count - 1))) {
-                       printk(KERN_ERR PREFIX "Invalid tx\n");
-                       return -EINVAL;
-               }
-               pr->limit.user.tx = tx;
-       }
-
-       result = acpi_processor_apply_limit(pr);
-
-       return count;
-}
-
-const struct file_operations acpi_processor_limit_fops = {
-       .owner = THIS_MODULE,
-       .open = acpi_processor_limit_open_fs,
-       .read = seq_read,
-       .write = acpi_processor_write_limit,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-#endif
index 9ade1a5b32edbef3b07142cac70cfa116ce31b89..730863855ed54ebdb49c35cca733bf3a92596c0d 100644 (file)
@@ -1215,7 +1215,6 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
 }
 
 /* proc interface */
-#ifdef CONFIG_ACPI_PROCFS
 static int acpi_processor_throttling_seq_show(struct seq_file *seq,
                                              void *offset)
 {
@@ -1323,4 +1322,3 @@ const struct file_operations acpi_processor_throttling_fops = {
        .llseek = seq_lseek,
        .release = single_release,
 };
-#endif
index e143203254a47d5799915066133a23e83878a34a..cf82989ae7568c3c54ded69d16829a2851119d80 100644 (file)
@@ -70,10 +70,10 @@ static int acpi_sleep_prepare(u32 acpi_state)
 
        }
        ACPI_FLUSH_CPU_CACHE();
-       acpi_enable_wakeup_device_prep(acpi_state);
 #endif
        printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
                acpi_state);
+       acpi_enable_wakeup_devices(acpi_state);
        acpi_enter_sleep_state_prep(acpi_state);
        return 0;
 }
@@ -118,6 +118,16 @@ static int acpi_pm_freeze(void)
        return 0;
 }
 
+/**
+ * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
+ */
+static int acpi_pm_pre_suspend(void)
+{
+       acpi_pm_freeze();
+       suspend_nvs_save();
+       return 0;
+}
+
 /**
  *     __acpi_pm_prepare - Prepare the platform to enter the target state.
  *
@@ -127,11 +137,9 @@ static int acpi_pm_freeze(void)
 static int __acpi_pm_prepare(void)
 {
        int error = acpi_sleep_prepare(acpi_target_sleep_state);
-
-       suspend_nvs_save();
-
        if (error)
                acpi_target_sleep_state = ACPI_STATE_S0;
+
        return error;
 }
 
@@ -142,9 +150,8 @@ static int __acpi_pm_prepare(void)
 static int acpi_pm_prepare(void)
 {
        int error = __acpi_pm_prepare();
-
        if (!error)
-               acpi_pm_freeze();
+               acpi_pm_pre_suspend();
 
        return error;
 }
@@ -159,7 +166,6 @@ static void acpi_pm_finish(void)
 {
        u32 acpi_state = acpi_target_sleep_state;
 
-       suspend_nvs_free();
        acpi_ec_unblock_transactions();
 
        if (acpi_state == ACPI_STATE_S0)
@@ -167,7 +173,7 @@ static void acpi_pm_finish(void)
 
        printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
                acpi_state);
-       acpi_disable_wakeup_device(acpi_state);
+       acpi_disable_wakeup_devices(acpi_state);
        acpi_leave_sleep_state(acpi_state);
 
        /* reset firmware waking vector */
@@ -181,6 +187,7 @@ static void acpi_pm_finish(void)
  */
 static void acpi_pm_end(void)
 {
+       suspend_nvs_free();
        /*
         * This is necessary in case acpi_pm_finish() is not called during a
         * failing transition to a sleep state.
@@ -251,7 +258,6 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
        }
 
        local_irq_save(flags);
-       acpi_enable_wakeup_device(acpi_state);
        switch (acpi_state) {
        case ACPI_STATE_S1:
                barrier();
@@ -297,11 +303,6 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
        return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 }
 
-static void acpi_suspend_finish(void)
-{
-       acpi_pm_finish();
-}
-
 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 {
        u32 acpi_state;
@@ -323,7 +324,7 @@ static struct platform_suspend_ops acpi_suspend_ops = {
        .begin = acpi_suspend_begin,
        .prepare_late = acpi_pm_prepare,
        .enter = acpi_suspend_enter,
-       .wake = acpi_suspend_finish,
+       .wake = acpi_pm_finish,
        .end = acpi_pm_end,
 };
 
@@ -336,9 +337,9 @@ static struct platform_suspend_ops acpi_suspend_ops = {
 static int acpi_suspend_begin_old(suspend_state_t pm_state)
 {
        int error = acpi_suspend_begin(pm_state);
-
        if (!error)
                error = __acpi_pm_prepare();
+
        return error;
 }
 
@@ -349,9 +350,9 @@ static int acpi_suspend_begin_old(suspend_state_t pm_state)
 static struct platform_suspend_ops acpi_suspend_ops_old = {
        .valid = acpi_suspend_state_valid,
        .begin = acpi_suspend_begin_old,
-       .prepare_late = acpi_pm_freeze,
+       .prepare_late = acpi_pm_pre_suspend,
        .enter = acpi_suspend_enter,
-       .wake = acpi_suspend_finish,
+       .wake = acpi_pm_finish,
        .end = acpi_pm_end,
        .recover = acpi_pm_finish,
 };
@@ -423,16 +424,6 @@ static int acpi_hibernation_begin(void)
        return error;
 }
 
-static int acpi_hibernation_pre_snapshot(void)
-{
-       int error = acpi_pm_prepare();
-
-       if (!error)
-               suspend_nvs_save();
-
-       return error;
-}
-
 static int acpi_hibernation_enter(void)
 {
        acpi_status status = AE_OK;
@@ -441,7 +432,6 @@ static int acpi_hibernation_enter(void)
        ACPI_FLUSH_CPU_CACHE();
 
        local_irq_save(flags);
-       acpi_enable_wakeup_device(ACPI_STATE_S4);
        /* This shouldn't return.  If it returns, we have a problem */
        status = acpi_enter_sleep_state(ACPI_STATE_S4);
        /* Reprogram control registers and execute _BFS */
@@ -481,7 +471,7 @@ static void acpi_pm_thaw(void)
 static struct platform_hibernation_ops acpi_hibernation_ops = {
        .begin = acpi_hibernation_begin,
        .end = acpi_pm_end,
-       .pre_snapshot = acpi_hibernation_pre_snapshot,
+       .pre_snapshot = acpi_pm_prepare,
        .finish = acpi_pm_finish,
        .prepare = acpi_pm_prepare,
        .enter = acpi_hibernation_enter,
@@ -517,13 +507,6 @@ static int acpi_hibernation_begin_old(void)
        return error;
 }
 
-static int acpi_hibernation_pre_snapshot_old(void)
-{
-       acpi_pm_freeze();
-       suspend_nvs_save();
-       return 0;
-}
-
 /*
  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
  * been requested.
@@ -531,7 +514,7 @@ static int acpi_hibernation_pre_snapshot_old(void)
 static struct platform_hibernation_ops acpi_hibernation_ops_old = {
        .begin = acpi_hibernation_begin_old,
        .end = acpi_pm_end,
-       .pre_snapshot = acpi_hibernation_pre_snapshot_old,
+       .pre_snapshot = acpi_pm_pre_suspend,
        .prepare = acpi_pm_freeze,
        .finish = acpi_pm_finish,
        .enter = acpi_hibernation_enter,
@@ -686,7 +669,6 @@ static void acpi_power_off(void)
        /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
        printk(KERN_DEBUG "%s called\n", __func__);
        local_irq_disable();
-       acpi_enable_wakeup_device(ACPI_STATE_S5);
        acpi_enter_sleep_state(ACPI_STATE_S5);
 }
 
index 25b8bd149284fb7f13de1018bf66c806dd855f9e..d8821805c3bc9ab4637732d5d7ee6f105620b83f 100644 (file)
@@ -2,9 +2,8 @@
 extern u8 sleep_states[];
 extern int acpi_suspend(u32 state);
 
-extern void acpi_enable_wakeup_device_prep(u8 sleep_state);
-extern void acpi_enable_wakeup_device(u8 sleep_state);
-extern void acpi_disable_wakeup_device(u8 sleep_state);
+extern void acpi_enable_wakeup_devices(u8 sleep_state);
+extern void acpi_disable_wakeup_devices(u8 sleep_state);
 
 extern struct list_head acpi_wakeup_device_list;
 extern struct mutex acpi_device_lock;
similarity index 57%
rename from drivers/acpi/system.c
rename to drivers/acpi/sysfs.c
index 5981bd07e20e6f5d467764bf5468ba6a3ecabe61..68e2e4582fa2f18968058c8125704a23f151cb62 100644 (file)
 /*
- *  acpi_system.c - ACPI System Driver ($Revision: 63 $)
- *
- *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
- *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or (at
- *  your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * sysfs.c - ACPI sysfs interface to userspace.
  */
 
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/slab.h>
 #include <linux/init.h>
-#include <linux/string.h>
-#include <asm/uaccess.h>
-
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
 #include <acpi/acpi_drivers.h>
 
-#define PREFIX "ACPI: "
-
 #define _COMPONENT             ACPI_SYSTEM_COMPONENT
-ACPI_MODULE_NAME("system");
-
-#define ACPI_SYSTEM_CLASS              "system"
-#define ACPI_SYSTEM_DEVICE_NAME                "System"
+ACPI_MODULE_NAME("sysfs");
 
-u32 acpi_irq_handled;
-u32 acpi_irq_not_handled;
+#define PREFIX "ACPI: "
 
+#ifdef CONFIG_ACPI_DEBUG
 /*
- * Make ACPICA version work as module param
+ * ACPI debug sysfs I/F, including:
+ * /sys/modules/acpi/parameters/debug_layer
+ * /sys/modules/acpi/parameters/debug_level
+ * /sys/modules/acpi/parameters/trace_method_name
+ * /sys/modules/acpi/parameters/trace_state
+ * /sys/modules/acpi/parameters/trace_debug_layer
+ * /sys/modules/acpi/parameters/trace_debug_level
  */
+
+struct acpi_dlayer {
+       const char *name;
+       unsigned long value;
+};
+struct acpi_dlevel {
+       const char *name;
+       unsigned long value;
+};
+#define ACPI_DEBUG_INIT(v)     { .name = #v, .value = v }
+
+static const struct acpi_dlayer acpi_debug_layers[] = {
+       ACPI_DEBUG_INIT(ACPI_UTILITIES),
+       ACPI_DEBUG_INIT(ACPI_HARDWARE),
+       ACPI_DEBUG_INIT(ACPI_EVENTS),
+       ACPI_DEBUG_INIT(ACPI_TABLES),
+       ACPI_DEBUG_INIT(ACPI_NAMESPACE),
+       ACPI_DEBUG_INIT(ACPI_PARSER),
+       ACPI_DEBUG_INIT(ACPI_DISPATCHER),
+       ACPI_DEBUG_INIT(ACPI_EXECUTER),
+       ACPI_DEBUG_INIT(ACPI_RESOURCES),
+       ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER),
+       ACPI_DEBUG_INIT(ACPI_OS_SERVICES),
+       ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER),
+       ACPI_DEBUG_INIT(ACPI_COMPILER),
+       ACPI_DEBUG_INIT(ACPI_TOOLS),
+
+       ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_AC_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT),
+       ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT),
+};
+
+static const struct acpi_dlevel acpi_debug_levels[] = {
+       ACPI_DEBUG_INIT(ACPI_LV_INIT),
+       ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT),
+       ACPI_DEBUG_INIT(ACPI_LV_INFO),
+
+       ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES),
+       ACPI_DEBUG_INIT(ACPI_LV_PARSE),
+       ACPI_DEBUG_INIT(ACPI_LV_LOAD),
+       ACPI_DEBUG_INIT(ACPI_LV_DISPATCH),
+       ACPI_DEBUG_INIT(ACPI_LV_EXEC),
+       ACPI_DEBUG_INIT(ACPI_LV_NAMES),
+       ACPI_DEBUG_INIT(ACPI_LV_OPREGION),
+       ACPI_DEBUG_INIT(ACPI_LV_BFIELD),
+       ACPI_DEBUG_INIT(ACPI_LV_TABLES),
+       ACPI_DEBUG_INIT(ACPI_LV_VALUES),
+       ACPI_DEBUG_INIT(ACPI_LV_OBJECTS),
+       ACPI_DEBUG_INIT(ACPI_LV_RESOURCES),
+       ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS),
+       ACPI_DEBUG_INIT(ACPI_LV_PACKAGE),
+
+       ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS),
+       ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS),
+       ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS),
+
+       ACPI_DEBUG_INIT(ACPI_LV_MUTEX),
+       ACPI_DEBUG_INIT(ACPI_LV_THREADS),
+       ACPI_DEBUG_INIT(ACPI_LV_IO),
+       ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS),
+
+       ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE),
+       ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO),
+       ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES),
+       ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
+};
+
+static int param_get_debug_layer(char *buffer, struct kernel_param *kp)
+{
+       int result = 0;
+       int i;
+
+       result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
+
+       for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
+               result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
+                                 acpi_debug_layers[i].name,
+                                 acpi_debug_layers[i].value,
+                                 (acpi_dbg_layer & acpi_debug_layers[i].value)
+                                 ? '*' : ' ');
+       }
+       result +=
+           sprintf(buffer + result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
+                   ACPI_ALL_DRIVERS,
+                   (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
+                   ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS)
+                   == 0 ? ' ' : '-');
+       result +=
+           sprintf(buffer + result,
+                   "--\ndebug_layer = 0x%08X ( * = enabled)\n",
+                   acpi_dbg_layer);
+
+       return result;
+}
+
+static int param_get_debug_level(char *buffer, struct kernel_param *kp)
+{
+       int result = 0;
+       int i;
+
+       result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
+
+       for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
+               result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
+                                 acpi_debug_levels[i].name,
+                                 acpi_debug_levels[i].value,
+                                 (acpi_dbg_level & acpi_debug_levels[i].value)
+                                 ? '*' : ' ');
+       }
+       result +=
+           sprintf(buffer + result, "--\ndebug_level = 0x%08X (* = enabled)\n",
+                   acpi_dbg_level);
+
+       return result;
+}
+
+module_param_call(debug_layer, param_set_uint, param_get_debug_layer,
+                 &acpi_dbg_layer, 0644);
+module_param_call(debug_level, param_set_uint, param_get_debug_level,
+                 &acpi_dbg_level, 0644);
+
+static char trace_method_name[6];
+module_param_string(trace_method_name, trace_method_name, 6, 0644);
+static unsigned int trace_debug_layer;
+module_param(trace_debug_layer, uint, 0644);
+static unsigned int trace_debug_level;
+module_param(trace_debug_level, uint, 0644);
+
+static int param_set_trace_state(const char *val, struct kernel_param *kp)
+{
+       int result = 0;
+
+       if (!strncmp(val, "enable", strlen("enable") - 1)) {
+               result = acpi_debug_trace(trace_method_name, trace_debug_level,
+                                         trace_debug_layer, 0);
+               if (result)
+                       result = -EBUSY;
+               goto exit;
+       }
+
+       if (!strncmp(val, "disable", strlen("disable") - 1)) {
+               int name = 0;
+               result = acpi_debug_trace((char *)&name, trace_debug_level,
+                                         trace_debug_layer, 0);
+               if (result)
+                       result = -EBUSY;
+               goto exit;
+       }
+
+       if (!strncmp(val, "1", 1)) {
+               result = acpi_debug_trace(trace_method_name, trace_debug_level,
+                                         trace_debug_layer, 1);
+               if (result)
+                       result = -EBUSY;
+               goto exit;
+       }
+
+       result = -EINVAL;
+exit:
+       return result;
+}
+
+static int param_get_trace_state(char *buffer, struct kernel_param *kp)
+{
+       if (!acpi_gbl_trace_method_name)
+               return sprintf(buffer, "disable");
+       else {
+               if (acpi_gbl_trace_flags & 1)
+                       return sprintf(buffer, "1");
+               else
+                       return sprintf(buffer, "enable");
+       }
+       return 0;
+}
+
+module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
+                 NULL, 0644);
+#endif /* CONFIG_ACPI_DEBUG */
+
+/* /sys/module/acpi/parameters/acpica_version */
 static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
 {
        int result;
@@ -57,9 +224,12 @@ static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
 
 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/sys)
-   -------------------------------------------------------------------------- */
+/*
+ * ACPI table sysfs I/F:
+ * /sys/firmware/acpi/tables/
+ * /sys/firmware/acpi/tables/dynamic/
+ */
+
 static LIST_HEAD(acpi_table_attr_list);
 static struct kobject *tables_kobj;
 static struct kobject *dynamic_tables_kobj;
@@ -86,14 +256,12 @@ static ssize_t acpi_table_show(struct file *filp, struct kobject *kobj,
        else
                memcpy(name, "\0\0\0\0", 4);
 
-       status =
-           acpi_get_table(name, table_attr->instance,
-                          &table_header);
+       status = acpi_get_table(name, table_attr->instance, &table_header);
        if (ACPI_FAILURE(status))
                return -ENODEV;
 
        return memory_read_from_buffer(buf, count, &offset,
-                                       table_header, table_header->length);
+                                      table_header, table_header->length);
 }
 
 static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
@@ -105,7 +273,7 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
        sysfs_attr_init(&table_attr->attr.attr);
        if (table_header->signature[0] != '\0')
                memcpy(table_attr->name, table_header->signature,
-                       ACPI_NAME_SIZE);
+                      ACPI_NAME_SIZE);
        else
                memcpy(table_attr->name, "NULL", 4);
 
@@ -117,8 +285,8 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
        table_attr->instance++;
 
        if (table_attr->instance > 1 || (table_attr->instance == 1 &&
-                                       !acpi_get_table
-                                       (table_header->signature, 2, &header)))
+                                        !acpi_get_table
+                                        (table_header->signature, 2, &header)))
                sprintf(table_attr->name + ACPI_NAME_SIZE, "%d",
                        table_attr->instance);
 
@@ -138,18 +306,17 @@ acpi_sysfs_table_handler(u32 event, void *table, void *context)
        switch (event) {
        case ACPI_TABLE_EVENT_LOAD:
                table_attr =
-                       kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
+                   kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
                if (!table_attr)
                        return AE_NO_MEMORY;
 
                acpi_table_attr_init(table_attr, table);
                if (sysfs_create_bin_file(dynamic_tables_kobj,
-                                       &table_attr->attr)) {
+                                         &table_attr->attr)) {
                        kfree(table_attr);
                        return AE_ERROR;
                } else
-                       list_add_tail(&table_attr->node,
-                                       &acpi_table_attr_list);
+                       list_add_tail(&table_attr->node, &acpi_table_attr_list);
                break;
        case ACPI_TABLE_EVENT_UNLOAD:
                /*
@@ -164,7 +331,7 @@ acpi_sysfs_table_handler(u32 event, void *table, void *context)
        return AE_OK;
 }
 
-static int acpi_system_sysfs_init(void)
+static int acpi_tables_sysfs_init(void)
 {
        struct acpi_table_attr *table_attr;
        struct acpi_table_header *table_header = NULL;
@@ -213,14 +380,17 @@ err:
 }
 
 /*
- * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
- * See Documentation/ABI/testing/sysfs-firmware-acpi
+ * Detailed ACPI IRQ counters:
+ * /sys/firmware/acpi/interrupts/
  */
 
+u32 acpi_irq_handled;
+u32 acpi_irq_not_handled;
+
 #define COUNT_GPE 0
-#define COUNT_SCI 1    /* acpi_irq_handled */
-#define COUNT_SCI_NOT 2        /* acpi_irq_not_handled */
-#define COUNT_ERROR 3  /* other */
+#define COUNT_SCI 1            /* acpi_irq_handled */
+#define COUNT_SCI_NOT 2                /* acpi_irq_not_handled */
+#define COUNT_ERROR 3          /* other */
 #define NUM_COUNTERS_EXTRA 4
 
 struct event_counter {
@@ -237,6 +407,7 @@ static u32 acpi_gpe_count;
 static struct attribute_group interrupt_stats_attr_group = {
        .name = "interrupts",
 };
+
 static struct kobj_attribute *counter_attrs;
 
 static void delete_gpe_attr_array(void)
@@ -269,8 +440,8 @@ void acpi_os_gpe_count(u32 gpe_number)
        if (gpe_number < num_gpes)
                all_counters[gpe_number].count++;
        else
-               all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
-                                       count++;
+               all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS +
+                            COUNT_ERROR].count++;
 
        return;
 }
@@ -283,13 +454,14 @@ void acpi_os_fixed_event_count(u32 event_number)
        if (event_number < ACPI_NUM_FIXED_EVENTS)
                all_counters[num_gpes + event_number].count++;
        else
-               all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
-                               count++;
+               all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS +
+                            COUNT_ERROR].count++;
 
        return;
 }
 
-static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
+static int get_status(u32 index, acpi_event_status *status,
+                     acpi_handle *handle)
 {
        int result = 0;
 
@@ -300,7 +472,7 @@ static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
                result = acpi_get_gpe_device(index, handle);
                if (result) {
                        ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
-                               "Invalid GPE 0x%x\n", index));
+                                       "Invalid GPE 0x%x\n", index));
                        goto end;
                }
                result = acpi_get_gpe_status(*handle, index, status);
@@ -312,7 +484,7 @@ end:
 }
 
 static ssize_t counter_show(struct kobject *kobj,
-       struct kobj_attribute *attr, char *buf)
+                           struct kobj_attribute *attr, char *buf)
 {
        int index = attr - counter_attrs;
        int size;
@@ -321,12 +493,11 @@ static ssize_t counter_show(struct kobject *kobj,
        int result = 0;
 
        all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
-               acpi_irq_handled;
+           acpi_irq_handled;
        all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count =
-               acpi_irq_not_handled;
+           acpi_irq_not_handled;
        all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
-               acpi_gpe_count;
-
+           acpi_gpe_count;
        size = sprintf(buf, "%8d", all_counters[index].count);
 
        /* "gpe_all" or "sci" */
@@ -338,13 +509,13 @@ static ssize_t counter_show(struct kobject *kobj,
                goto end;
 
        if (!(status & ACPI_EVENT_FLAG_HANDLE))
-               size += sprintf(buf + size, "   invalid");
+               size += sprintf(buf + size, "   invalid");
        else if (status & ACPI_EVENT_FLAG_ENABLED)
-               size += sprintf(buf + size, "   enabled");
+               size += sprintf(buf + size, "   enabled");
        else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
-               size += sprintf(buf + size, "   wake_enabled");
+               size += sprintf(buf + size, "   wake_enabled");
        else
-               size += sprintf(buf + size, "   disabled");
+               size += sprintf(buf + size, "   disabled");
 
 end:
        size += sprintf(buf + size, "\n");
@@ -357,7 +528,8 @@ end:
  * enable/disable/clear a gpe/fixed event in user space.
  */
 static ssize_t counter_set(struct kobject *kobj,
-       struct kobj_attribute *attr, const char *buf, size_t size)
+                          struct kobj_attribute *attr, const char *buf,
+                          size_t size)
 {
        int index = attr - counter_attrs;
        acpi_event_status status;
@@ -381,32 +553,32 @@ static ssize_t counter_set(struct kobject *kobj,
 
        if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
                printk(KERN_WARNING PREFIX
-                       "Can not change Invalid GPE/Fixed Event status\n");
+                      "Can not change Invalid GPE/Fixed Event status\n");
                return -EINVAL;
        }
 
        if (index < num_gpes) {
                if (!strcmp(buf, "disable\n") &&
-                               (status & ACPI_EVENT_FLAG_ENABLED))
+                   (status & ACPI_EVENT_FLAG_ENABLED))
                        result = acpi_disable_gpe(handle, index);
                else if (!strcmp(buf, "enable\n") &&
-                               !(status & ACPI_EVENT_FLAG_ENABLED))
+                        !(status & ACPI_EVENT_FLAG_ENABLED))
                        result = acpi_enable_gpe(handle, index);
                else if (!strcmp(buf, "clear\n") &&
-                               (status & ACPI_EVENT_FLAG_SET))
+                        (status & ACPI_EVENT_FLAG_SET))
                        result = acpi_clear_gpe(handle, index);
                else
                        all_counters[index].count = strtoul(buf, NULL, 0);
        } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
                int event = index - num_gpes;
                if (!strcmp(buf, "disable\n") &&
-                               (status & ACPI_EVENT_FLAG_ENABLED))
+                   (status & ACPI_EVENT_FLAG_ENABLED))
                        result = acpi_disable_event(event, ACPI_NOT_ISR);
                else if (!strcmp(buf, "enable\n") &&
-                               !(status & ACPI_EVENT_FLAG_ENABLED))
+                        !(status & ACPI_EVENT_FLAG_ENABLED))
                        result = acpi_enable_event(event, ACPI_NOT_ISR);
                else if (!strcmp(buf, "clear\n") &&
-                               (status & ACPI_EVENT_FLAG_SET))
+                        (status & ACPI_EVENT_FLAG_SET))
                        result = acpi_clear_event(event);
                else
                        all_counters[index].count = strtoul(buf, NULL, 0);
@@ -430,17 +602,17 @@ void acpi_irq_stats_init(void)
        num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
 
        all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
-                       GFP_KERNEL);
+                           GFP_KERNEL);
        if (all_attrs == NULL)
                return;
 
        all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
-                               GFP_KERNEL);
+                              GFP_KERNEL);
        if (all_counters == NULL)
                goto fail;
 
        counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
-                       GFP_KERNEL);
+                               GFP_KERNEL);
        if (counter_attrs == NULL)
                goto fail;
 
@@ -503,135 +675,11 @@ static void __exit interrupt_stats_exit(void)
        return;
 }
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-#ifdef CONFIG_ACPI_PROCFS
-#define ACPI_SYSTEM_FILE_INFO          "info"
-#define ACPI_SYSTEM_FILE_EVENT         "event"
-#define ACPI_SYSTEM_FILE_DSDT          "dsdt"
-#define ACPI_SYSTEM_FILE_FADT          "fadt"
-
-static int acpi_system_read_info(struct seq_file *seq, void *offset)
-{
-
-       seq_printf(seq, "version:                 %x\n", ACPI_CA_VERSION);
-       return 0;
-}
-
-static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
-{
-       return single_open(file, acpi_system_read_info, PDE(inode)->data);
-}
-
-static const struct file_operations acpi_system_info_ops = {
-       .owner = THIS_MODULE,
-       .open = acpi_system_info_open_fs,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-
-static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
-                                    loff_t *);
-
-static const struct file_operations acpi_system_dsdt_ops = {
-       .owner = THIS_MODULE,
-       .read = acpi_system_read_dsdt,
-};
-
-static ssize_t
-acpi_system_read_dsdt(struct file *file,
-                     char __user * buffer, size_t count, loff_t * ppos)
-{
-       acpi_status status = AE_OK;
-       struct acpi_table_header *dsdt = NULL;
-       ssize_t res;
-
-       status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
-       if (ACPI_FAILURE(status))
-               return -ENODEV;
-
-       res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
-
-       return res;
-}
-
-static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
-                                    loff_t *);
-
-static const struct file_operations acpi_system_fadt_ops = {
-       .owner = THIS_MODULE,
-       .read = acpi_system_read_fadt,
-};
-
-static ssize_t
-acpi_system_read_fadt(struct file *file,
-                     char __user * buffer, size_t count, loff_t * ppos)
-{
-       acpi_status status = AE_OK;
-       struct acpi_table_header *fadt = NULL;
-       ssize_t res;
-
-       status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
-       if (ACPI_FAILURE(status))
-               return -ENODEV;
-
-       res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
-
-       return res;
-}
-
-static int acpi_system_procfs_init(void)
-{
-       struct proc_dir_entry *entry;
-       int error = 0;
-
-       /* 'info' [R] */
-       entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
-                           &acpi_system_info_ops);
-       if (!entry)
-               goto Error;
-
-       /* 'dsdt' [R] */
-       entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
-                           &acpi_system_dsdt_ops);
-       if (!entry)
-               goto Error;
-
-       /* 'fadt' [R] */
-       entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
-                           &acpi_system_fadt_ops);
-       if (!entry)
-               goto Error;
-
-      Done:
-       return error;
-
-      Error:
-       remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
-       remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
-       remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
-
-       error = -EFAULT;
-       goto Done;
-}
-#else
-static int acpi_system_procfs_init(void)
-{
-       return 0;
-}
-#endif
-
-int __init acpi_system_init(void)
+int __init acpi_sysfs_init(void)
 {
        int result;
 
-       result = acpi_system_procfs_init();
-       if (result)
-               return result;
-
-       result = acpi_system_sysfs_init();
+       result = acpi_tables_sysfs_init();
 
        return result;
 }
index efad1f33aeb588b1c4910697ac97dfcfc2ad2b92..2f8f17131d9fb9b19094284fcfa2dd5f0092f7b8 100644 (file)
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/types.h>
+
+#ifdef CONFIG_ACPI_PROCFS
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#endif
+
 #include <linux/jiffies.h>
 #include <linux/kmod.h>
-#include <linux/seq_file.h>
 #include <linux/reboot.h>
 #include <linux/device.h>
 #include <asm/uaccess.h>
@@ -102,16 +106,6 @@ static int acpi_thermal_add(struct acpi_device *device);
 static int acpi_thermal_remove(struct acpi_device *device, int type);
 static int acpi_thermal_resume(struct acpi_device *device);
 static void acpi_thermal_notify(struct acpi_device *device, u32 event);
-static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
-static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
-static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
-static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
-static ssize_t acpi_thermal_write_cooling_mode(struct file *,
-                                              const char __user *, size_t,
-                                              loff_t *);
-static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
-static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
-                                         size_t, loff_t *);
 
 static const struct acpi_device_id  thermal_device_ids[] = {
        {ACPI_THERMAL_HID, 0},
@@ -201,6 +195,18 @@ struct acpi_thermal {
        struct mutex lock;
 };
 
+#ifdef CONFIG_ACPI_PROCFS
+static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
+static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
+static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
+static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
+static ssize_t acpi_thermal_write_cooling_mode(struct file *,
+                                              const char __user *, size_t,
+                                              loff_t *);
+static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
+static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
+                                         size_t, loff_t *);
+
 static const struct file_operations acpi_thermal_state_fops = {
        .owner = THIS_MODULE,
        .open = acpi_thermal_state_open_fs,
@@ -242,6 +248,7 @@ static const struct file_operations acpi_thermal_polling_fops = {
        .llseek = seq_lseek,
        .release = single_release,
 };
+#endif /* CONFIG_ACPI_PROCFS*/
 
 /* --------------------------------------------------------------------------
                              Thermal Zone Management
@@ -287,26 +294,6 @@ static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
        return 0;
 }
 
-static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
-{
-
-       if (!tz)
-               return -EINVAL;
-
-       tz->polling_frequency = seconds * 10;   /* Convert value to deci-seconds */
-
-       tz->thermal_zone->polling_delay = seconds * 1000;
-
-       if (tz->tz_enabled)
-               thermal_zone_device_update(tz->thermal_zone);
-
-       ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                         "Polling frequency set to %lu seconds\n",
-                         tz->polling_frequency/10));
-
-       return 0;
-}
-
 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
 {
        acpi_status status = AE_OK;
@@ -973,7 +960,7 @@ static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
 /* --------------------------------------------------------------------------
                               FS Interface (/proc)
    -------------------------------------------------------------------------- */
-
+#ifdef CONFIG_ACPI_PROCFS
 static struct proc_dir_entry *acpi_thermal_dir;
 
 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
@@ -1187,6 +1174,26 @@ static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
                           PDE(inode)->data);
 }
 
+static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
+{
+       if (!tz)
+               return -EINVAL;
+
+       /* Convert value to deci-seconds */
+       tz->polling_frequency = seconds * 10;
+
+       tz->thermal_zone->polling_delay = seconds * 1000;
+
+       if (tz->tz_enabled)
+               thermal_zone_device_update(tz->thermal_zone);
+
+       ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                         "Polling frequency set to %lu seconds\n",
+                         tz->polling_frequency/10));
+
+       return 0;
+}
+
 static ssize_t
 acpi_thermal_write_polling(struct file *file,
                           const char __user * buffer,
@@ -1295,7 +1302,13 @@ static int acpi_thermal_remove_fs(struct acpi_device *device)
 
        return 0;
 }
-
+#else
+static inline int acpi_thermal_add_fs(struct acpi_device *device) { return 0; }
+static inline int acpi_thermal_remove_fs(struct acpi_device *device)
+{
+       return 0;
+}
+#endif /* CONFIG_ACPI_PROCFS */
 /* --------------------------------------------------------------------------
                                  Driver Interface
    -------------------------------------------------------------------------- */
@@ -1566,13 +1579,18 @@ static int __init acpi_thermal_init(void)
                printk(KERN_NOTICE "ACPI: thermal control disabled\n");
                return -ENODEV;
        }
+
+#ifdef CONFIG_ACPI_PROCFS
        acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
        if (!acpi_thermal_dir)
                return -ENODEV;
+#endif
 
        result = acpi_bus_register_driver(&acpi_thermal_driver);
        if (result < 0) {
+#ifdef CONFIG_ACPI_PROCFS
                remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
+#endif
                return -ENODEV;
        }
 
@@ -1584,7 +1602,9 @@ static void __exit acpi_thermal_exit(void)
 
        acpi_bus_unregister_driver(&acpi_thermal_driver);
 
+#ifdef CONFIG_ACPI_PROCFS
        remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
+#endif
 
        return;
 }
index 9865d46f49a8faabfe0930640b2fe3bbd10b4b89..67dec0c675aae4d59e71c689ccc450ff5896c5c6 100644 (file)
@@ -152,7 +152,9 @@ struct acpi_video_bus {
        struct acpi_video_bus_flags flags;
        struct list_head video_device_list;
        struct mutex device_list_lock;  /* protects video_device_list */
+#ifdef CONFIG_ACPI_PROCFS
        struct proc_dir_entry *dir;
+#endif
        struct input_dev *input;
        char phys[32];  /* for input device */
        struct notifier_block pm_nb;
@@ -208,6 +210,7 @@ struct acpi_video_device {
        struct output_device *output_dev;
 };
 
+#ifdef CONFIG_ACPI_PROCFS
 /* bus */
 static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file);
 static const struct file_operations acpi_video_bus_info_fops = {
@@ -307,6 +310,7 @@ static const struct file_operations acpi_video_device_EDID_fops = {
        .llseek = seq_lseek,
        .release = single_release,
 };
+#endif /* CONFIG_ACPI_PROCFS */
 
 static const char device_decode[][30] = {
        "motherboard VGA device",
@@ -449,16 +453,6 @@ static struct thermal_cooling_device_ops video_cooling_ops = {
 
 /* device */
 
-static int
-acpi_video_device_query(struct acpi_video_device *device, unsigned long long *state)
-{
-       int status;
-
-       status = acpi_evaluate_integer(device->dev->handle, "_DGS", NULL, state);
-
-       return status;
-}
-
 static int
 acpi_video_device_get_state(struct acpi_video_device *device,
                            unsigned long long *state)
@@ -698,46 +692,6 @@ acpi_video_device_EDID(struct acpi_video_device *device,
 
 /* bus */
 
-static int
-acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
-{
-       int status;
-       unsigned long long tmp;
-       union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-       struct acpi_object_list args = { 1, &arg0 };
-
-
-       arg0.integer.value = option;
-
-       status = acpi_evaluate_integer(video->device->handle, "_SPD", &args, &tmp);
-       if (ACPI_SUCCESS(status))
-               status = tmp ? (-EINVAL) : (AE_OK);
-
-       return status;
-}
-
-static int
-acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
-{
-       int status;
-
-       status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
-
-       return status;
-}
-
-static int
-acpi_video_bus_POST_options(struct acpi_video_bus *video,
-                           unsigned long long *options)
-{
-       int status;
-
-       status = acpi_evaluate_integer(video->device->handle, "_VPO", NULL, options);
-       *options &= 3;
-
-       return status;
-}
-
 /*
  *  Arg:
  *     video           : video bus device pointer
@@ -1159,6 +1113,7 @@ static int acpi_video_bus_check(struct acpi_video_bus *video)
 /* --------------------------------------------------------------------------
                               FS Interface (/proc)
    -------------------------------------------------------------------------- */
+#ifdef CONFIG_ACPI_PROCFS
 
 static struct proc_dir_entry *acpi_video_dir;
 
@@ -1198,6 +1153,18 @@ acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
                           PDE(inode)->data);
 }
 
+static int
+acpi_video_device_query(struct acpi_video_device *device,
+                       unsigned long long *state)
+{
+       int status;
+
+       status = acpi_evaluate_integer(device->dev->handle, "_DGS",
+                                      NULL, state);
+
+       return status;
+}
+
 static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
 {
        int status;
@@ -1492,6 +1459,19 @@ static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
        return single_open(file, acpi_video_bus_ROM_seq_show, PDE(inode)->data);
 }
 
+static int
+acpi_video_bus_POST_options(struct acpi_video_bus *video,
+                           unsigned long long *options)
+{
+       int status;
+
+       status = acpi_evaluate_integer(video->device->handle, "_VPO",
+                                      NULL, options);
+       *options &= 3;
+
+       return status;
+}
+
 static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
 {
        struct acpi_video_bus *video = seq->private;
@@ -1530,6 +1510,16 @@ acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
                           PDE(inode)->data);
 }
 
+static int
+acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
+{
+       int status;
+
+       status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
+
+       return status;
+}
+
 static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
 {
        struct acpi_video_bus *video = seq->private;
@@ -1572,6 +1562,25 @@ static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file)
        return single_open(file, acpi_video_bus_DOS_seq_show, PDE(inode)->data);
 }
 
+static int
+acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
+{
+       int status;
+       unsigned long long tmp;
+       union acpi_object arg0 = { ACPI_TYPE_INTEGER };
+       struct acpi_object_list args = { 1, &arg0 };
+
+
+       arg0.integer.value = option;
+
+       status = acpi_evaluate_integer(video->device->handle, "_SPD",
+                                      &args, &tmp);
+       if (ACPI_SUCCESS(status))
+               status = tmp ? (-EINVAL) : (AE_OK);
+
+       return status;
+}
+
 static ssize_t
 acpi_video_bus_write_POST(struct file *file,
                          const char __user * buffer,
@@ -1722,6 +1731,24 @@ static int acpi_video_bus_remove_fs(struct acpi_device *device)
 
        return 0;
 }
+#else
+static inline int acpi_video_device_add_fs(struct acpi_device *device)
+{
+       return 0;
+}
+static inline int acpi_video_device_remove_fs(struct acpi_device *device)
+{
+       return 0;
+}
+static inline int acpi_video_bus_add_fs(struct acpi_device *device)
+{
+       return 0;
+}
+static inline int acpi_video_bus_remove_fs(struct acpi_device *device)
+{
+       return 0;
+}
+#endif /* CONFIG_ACPI_PROCFS */
 
 /* --------------------------------------------------------------------------
                                  Driver Interface
@@ -2140,7 +2167,7 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
                status = acpi_video_bus_get_one_device(dev, video);
                if (ACPI_FAILURE(status)) {
                        printk(KERN_WARNING PREFIX
-                                       "Cant attach device");
+                                       "Cant attach device\n");
                        continue;
                }
        }
@@ -2150,19 +2177,19 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
 static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
 {
        acpi_status status;
-       struct acpi_video_bus *video;
-
 
        if (!device || !device->video)
                return -ENOENT;
 
-       video = device->video;
-
        acpi_video_device_remove_fs(device->dev);
 
        status = acpi_remove_notify_handler(device->dev->handle,
                                            ACPI_DEVICE_NOTIFY,
                                            acpi_video_device_notify);
+       if (ACPI_FAILURE(status)) {
+               printk(KERN_WARNING PREFIX
+                      "Cant remove video notify handler\n");
+       }
        if (device->backlight) {
                sysfs_remove_link(&device->backlight->dev.kobj, "device");
                backlight_device_unregister(device->backlight);
@@ -2557,9 +2584,11 @@ int acpi_video_register(void)
                return 0;
        }
 
+#ifdef CONFIG_ACPI_PROCFS
        acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
        if (!acpi_video_dir)
                return -ENODEV;
+#endif
 
        result = acpi_bus_register_driver(&acpi_video_bus);
        if (result < 0) {
@@ -2588,7 +2617,9 @@ void acpi_video_unregister(void)
        }
        acpi_bus_unregister_driver(&acpi_video_bus);
 
+#ifdef CONFIG_ACPI_PROCFS
        remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
+#endif
 
        register_count = 0;
 
index c80537bc3234dd012a3e047907ad0c572b2e6f6a..f62a50c3ed3401e20fe7c0af8555584110cecb8e 100644 (file)
 ACPI_MODULE_NAME("wakeup_devices")
 
 /**
- * acpi_enable_wakeup_device_prep - Prepare wake-up devices.
+ * acpi_enable_wakeup_devices - Enable wake-up device GPEs.
  * @sleep_state: ACPI system sleep state.
  *
- * Enable all wake-up devices' power, unless the requested system sleep state is
- * too deep.
+ * Enable wakeup device power of devices with the state.enable flag set and set
+ * the wakeup enable mask bits in the GPE registers that correspond to wakeup
+ * devices.
  */
-void acpi_enable_wakeup_device_prep(u8 sleep_state)
+void acpi_enable_wakeup_devices(u8 sleep_state)
 {
        struct list_head *node, *next;
 
-       list_for_each_safe(node, next, &acpi_wakeup_device_list) {
-               struct acpi_device *dev = container_of(node,
-                                                      struct acpi_device,
-                                                      wakeup_list);
-
-               if (!dev->wakeup.flags.valid || !dev->wakeup.state.enabled
-                   || (sleep_state > (u32) dev->wakeup.sleep_state))
-                       continue;
-
-               acpi_enable_wakeup_device_power(dev, sleep_state);
-       }
-}
-
-/**
- * acpi_enable_wakeup_device - Enable wake-up device GPEs.
- * @sleep_state: ACPI system sleep state.
- *
- * Enable all wake-up devices' GPEs, with the assumption that
- * acpi_disable_all_gpes() was executed before, so we don't need to disable any
- * GPEs here.
- */
-void acpi_enable_wakeup_device(u8 sleep_state)
-{
-       struct list_head *node, *next;
-
-       /* 
-        * Caution: this routine must be invoked when interrupt is disabled 
-        * Refer ACPI2.0: P212
-        */
        list_for_each_safe(node, next, &acpi_wakeup_device_list) {
                struct acpi_device *dev =
                        container_of(node, struct acpi_device, wakeup_list);
@@ -69,6 +41,9 @@ void acpi_enable_wakeup_device(u8 sleep_state)
                    || sleep_state > (u32) dev->wakeup.sleep_state)
                        continue;
 
+               if (dev->wakeup.state.enabled)
+                       acpi_enable_wakeup_device_power(dev, sleep_state);
+
                /* The wake-up power should have been enabled already. */
                acpi_gpe_wakeup(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
                                ACPI_GPE_ENABLE);
@@ -76,13 +51,10 @@ void acpi_enable_wakeup_device(u8 sleep_state)
 }
 
 /**
- * acpi_disable_wakeup_device - Disable devices' wakeup capability.
+ * acpi_disable_wakeup_devices - Disable devices' wakeup capability.
  * @sleep_state: ACPI system sleep state.
- *
- * This function only affects devices with wakeup.state.enabled set, which means
- * that it reverses the changes made by acpi_enable_wakeup_device_prep().
  */
-void acpi_disable_wakeup_device(u8 sleep_state)
+void acpi_disable_wakeup_devices(u8 sleep_state)
 {
        struct list_head *node, *next;
 
index 7b5eea7e01dc83e5a42f0c075472ca67ef7e38ee..8b5ea399a4f4fa7dfe04765292f31af4c8750fba 100644 (file)
@@ -145,12 +145,6 @@ static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
        struct ata_eh_info *ehi = &ap->link.eh_info;
        int wait = 0;
        unsigned long flags;
-       acpi_handle handle;
-
-       if (dev)
-               handle = dev->acpi_handle;
-       else
-               handle = ap->acpi_handle;
 
        spin_lock_irqsave(ap->lock, flags);
        /*
index 81d4f3d4b9fdc70ff75ddda26f1fc0c65a8f7c7b..c0786d446a00b88adf144ab97f05af06679cccf7 100644 (file)
@@ -66,7 +66,7 @@ extern u8 acpi_gbl_create_osi_method;
 extern u8 acpi_gbl_use_default_register_widths;
 extern acpi_name acpi_gbl_trace_method_name;
 extern u32 acpi_gbl_trace_flags;
-extern u8 acpi_gbl_enable_aml_debug_object;
+extern u32 acpi_gbl_enable_aml_debug_object;
 extern u8 acpi_gbl_copy_dsdt_locally;
 extern u8 acpi_gbl_truncate_io_addresses;
 
index a68ca8a11a53a6cc06ff32190c16d4f84279ac29..1b62102fbb67e8b34e28dacf4bb323d424380c25 100644 (file)
@@ -338,7 +338,6 @@ extern struct cpuidle_driver acpi_idle_driver;
 
 /* in processor_thermal.c */
 int acpi_processor_get_limit_info(struct acpi_processor *pr);
-extern const struct file_operations acpi_processor_limit_fops;
 extern struct thermal_cooling_device_ops processor_cooling_ops;
 #ifdef CONFIG_CPU_FREQ
 void acpi_thermal_cpufreq_init(void);
index 4b38f905b7057d5eb015ee8c2b032f5b3cc8cf11..bf972f81e2a7233a1e269445101b4453c945b978 100644 (file)
  * Severity difinition for error_severity in struct cper_record_header
  * and section_severity in struct cper_section_descriptor
  */
-#define CPER_SER_RECOVERABLE                   0x0
-#define CPER_SER_FATAL                         0x1
-#define CPER_SER_CORRECTED                     0x2
-#define CPER_SER_INFORMATIONAL                 0x3
+#define CPER_SEV_RECOVERABLE                   0x0
+#define CPER_SEV_FATAL                         0x1
+#define CPER_SEV_CORRECTED                     0x2
+#define CPER_SEV_INFORMATIONAL                 0x3
 
 /*
  * Validation bits difinition for validation_bits in struct