Pull d-states into release branch
[linux-2.6.git] / drivers / acpi / sleep / main.c
index 54c2dfcf86511dec831693c86c0494f16e6a1028..ab21357c5c7b7d60dd15883981ea3016a94963b2 100644 (file)
@@ -34,35 +34,55 @@ static u32 acpi_suspend_states[] = {
 
 static int init_8259A_after_S1;
 
+extern int acpi_sleep_prepare(u32 acpi_state);
+extern void acpi_power_off(void);
+
+static u32 acpi_target_sleep_state = ACPI_STATE_S0;
+
+/**
+ *     acpi_pm_set_target - Set the target system sleep state to the state
+ *             associated with given @pm_state, if supported.
+ */
+
+static int acpi_pm_set_target(suspend_state_t pm_state)
+{
+       u32 acpi_state = acpi_suspend_states[pm_state];
+       int error = 0;
+
+       if (sleep_states[acpi_state]) {
+               acpi_target_sleep_state = acpi_state;
+       } else {
+               printk(KERN_ERR "ACPI does not support this state: %d\n",
+                       pm_state);
+               error = -ENOSYS;
+       }
+       return error;
+}
+
 /**
  *     acpi_pm_prepare - Do preliminary suspend work.
- *     @pm_state:              suspend state we're entering.
+ *     @pm_state: ignored
  *
- *     Make sure we support the state. If we do, and we need it, set the
- *     firmware waking vector and do arch-specific nastiness to get the 
- *     wakeup code to the waking vector. 
+ *     If necessary, set the firmware waking vector and do arch-specific
+ *     nastiness to get the wakeup code to the waking vector.
  */
 
-extern int acpi_sleep_prepare(u32 acpi_state);
-extern void acpi_power_off(void);
-
 static int acpi_pm_prepare(suspend_state_t pm_state)
 {
-       u32 acpi_state = acpi_suspend_states[pm_state];
+       int error = acpi_sleep_prepare(acpi_target_sleep_state);
 
-       if (!sleep_states[acpi_state]) {
-               printk("acpi_pm_prepare does not support %d \n", pm_state);
-               return -EPERM;
-       }
-       return acpi_sleep_prepare(acpi_state);
+       if (error)
+               acpi_target_sleep_state = ACPI_STATE_S0;
+
+       return error;
 }
 
 /**
  *     acpi_pm_enter - Actually enter a sleep state.
- *     @pm_state:              State we're entering.
+ *     @pm_state: ignored
  *
- *     Flush caches and go to sleep. For STR or STD, we have to call 
- *     arch-specific assembly, which in turn call acpi_enter_sleep_state().
+ *     Flush caches and go to sleep. For STR we have to call arch-specific
+ *     assembly, which in turn call acpi_enter_sleep_state().
  *     It's unfortunate, but it works. Please fix if you're feeling frisky.
  */
 
@@ -70,31 +90,31 @@ static int acpi_pm_enter(suspend_state_t pm_state)
 {
        acpi_status status = AE_OK;
        unsigned long flags = 0;
-       u32 acpi_state = acpi_suspend_states[pm_state];
+       u32 acpi_state = acpi_target_sleep_state;
 
        ACPI_FLUSH_CPU_CACHE();
 
        /* Do arch specific saving of state. */
-       if (pm_state > PM_SUSPEND_STANDBY) {
+       if (acpi_state == ACPI_STATE_S3) {
                int error = acpi_save_state_mem();
-               if (error)
+
+               if (error) {
+                       acpi_target_sleep_state = ACPI_STATE_S0;
                        return error;
+               }
        }
 
        local_irq_save(flags);
        acpi_enable_wakeup_device(acpi_state);
-       switch (pm_state) {
-       case PM_SUSPEND_STANDBY:
+       switch (acpi_state) {
+       case ACPI_STATE_S1:
                barrier();
                status = acpi_enter_sleep_state(acpi_state);
                break;
 
-       case PM_SUSPEND_MEM:
+       case ACPI_STATE_S3:
                do_suspend_lowlevel();
                break;
-
-       default:
-               return -EINVAL;
        }
 
        /* ACPI 3.0 specs (P62) says that it's the responsabilty
@@ -107,12 +127,8 @@ static int acpi_pm_enter(suspend_state_t pm_state)
        local_irq_restore(flags);
        printk(KERN_DEBUG "Back to C!\n");
 
-       /* restore processor state
-        * We should only be here if we're coming back from STR or STD.
-        * And, in the case of the latter, the memory image should have already
-        * been loaded from disk.
-        */
-       if (pm_state > PM_SUSPEND_STANDBY)
+       /* restore processor state */
+       if (acpi_state == ACPI_STATE_S3)
                acpi_restore_state_mem();
 
        return ACPI_SUCCESS(status) ? 0 : -EFAULT;
@@ -120,7 +136,7 @@ static int acpi_pm_enter(suspend_state_t pm_state)
 
 /**
  *     acpi_pm_finish - Finish up suspend sequence.
- *     @pm_state:              State we're coming out of.
+ *     @pm_state: ignored
  *
  *     This is called after we wake back up (or if entering the sleep state
  *     failed). 
@@ -128,7 +144,7 @@ static int acpi_pm_enter(suspend_state_t pm_state)
 
 static int acpi_pm_finish(suspend_state_t pm_state)
 {
-       u32 acpi_state = acpi_suspend_states[pm_state];
+       u32 acpi_state = acpi_target_sleep_state;
 
        acpi_leave_sleep_state(acpi_state);
        acpi_disable_wakeup_device(acpi_state);
@@ -136,6 +152,8 @@ static int acpi_pm_finish(suspend_state_t pm_state)
        /* reset firmware waking vector */
        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
 
+       acpi_target_sleep_state = ACPI_STATE_S0;
+
 #ifdef CONFIG_X86
        if (init_8259A_after_S1) {
                printk("Broken toshiba laptop -> kicking interrupts\n");
@@ -178,6 +196,7 @@ static int acpi_pm_state_valid(suspend_state_t pm_state)
 
 static struct pm_ops acpi_pm_ops = {
        .valid = acpi_pm_state_valid,
+       .set_target = acpi_pm_set_target,
        .prepare = acpi_pm_prepare,
        .enter = acpi_pm_enter,
        .finish = acpi_pm_finish,
@@ -237,6 +256,81 @@ static struct hibernation_ops acpi_hibernation_ops = {
 };
 #endif                         /* CONFIG_SOFTWARE_SUSPEND */
 
+/**
+ *     acpi_pm_device_sleep_state - return preferred power state of ACPI device
+ *             in the system sleep state given by %acpi_target_sleep_state
+ *     @dev: device to examine
+ *     @wake: if set, the device should be able to wake up the system
+ *     @d_min_p: used to store the upper limit of allowed states range
+ *     Return value: preferred power state of the device on success, -ENODEV on
+ *             failure (ie. if there's no 'struct acpi_device' for @dev)
+ *
+ *     Find the lowest power (highest number) ACPI device power state that
+ *     device @dev can be in while the system is in the sleep state represented
+ *     by %acpi_target_sleep_state.  If @wake is nonzero, the device should be
+ *     able to wake up the system from this sleep state.  If @d_min_p is set,
+ *     the highest power (lowest number) device power state of @dev allowed
+ *     in this system sleep state is stored at the location pointed to by it.
+ *
+ *     The caller must ensure that @dev is valid before using this function.
+ *     The caller is also responsible for figuring out if the device is
+ *     supposed to be able to wake up the system and passing this information
+ *     via @wake.
+ */
+
+int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
+{
+       acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
+       struct acpi_device *adev;
+       char acpi_method[] = "_SxD";
+       unsigned long d_min, d_max;
+
+       if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
+               printk(KERN_ERR "ACPI handle has no context!\n");
+               return -ENODEV;
+       }
+
+       acpi_method[2] = '0' + acpi_target_sleep_state;
+       /*
+        * If the sleep state is S0, we will return D3, but if the device has
+        * _S0W, we will use the value from _S0W
+        */
+       d_min = ACPI_STATE_D0;
+       d_max = ACPI_STATE_D3;
+
+       /*
+        * If present, _SxD methods return the minimum D-state (highest power
+        * state) we can use for the corresponding S-states.  Otherwise, the
+        * minimum D-state is D0 (ACPI 3.x).
+        *
+        * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
+        * provided -- that's our fault recovery, we ignore retval.
+        */
+       if (acpi_target_sleep_state > ACPI_STATE_S0)
+               acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
+
+       /*
+        * If _PRW says we can wake up the system from the target sleep state,
+        * the D-state returned by _SxD is sufficient for that (we assume a
+        * wakeup-aware driver if wake is set).  Still, if _SxW exists
+        * (ACPI 3.x), it should return the maximum (lowest power) D-state that
+        * can wake the system.  _S0W may be valid, too.
+        */
+       if (acpi_target_sleep_state == ACPI_STATE_S0 ||
+           (wake && adev->wakeup.state.enabled &&
+            adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
+               acpi_method[3] = 'W';
+               acpi_evaluate_integer(handle, acpi_method, NULL, &d_max);
+               /* Sanity check */
+               if (d_max < d_min)
+                       d_min = d_max;
+       }
+
+       if (d_min_p)
+               *d_min_p = d_min;
+       return d_max;
+}
+
 /*
  * Toshiba fails to preserve interrupts over S1, reinitialization
  * of 8259 is needed after S1 resume.