Linux电源管理_Wakeup count功能－－（三）

   1: do {

   2:     ret = read(&cnt, "/sys/power/wakeup_count");

   3:     if (ret) {

   4:         ret = write(cnt, "/sys/power/wakeup_count");

   5:     } else {

   6:         countine;

   7:     }

   8: } while (!ret);

   9:  

  10: write("mem", "/sys/power/state");

  11:  

  12: /* goto here after wakeup */

   1: /*

   2:  * The 'wakeup_count' attribute, along with the functions defined in

   3:  * drivers/base/power/wakeup.c, provides a means by which wakeup events can be

   4:  * handled in a non-racy way.

   5:  *

   6:  * If a wakeup event occurs when the system is in a sleep state, it simply is

   7:  * woken up.  In turn, if an event that would wake the system up from a sleep

   8:  * state occurs when it is undergoing a transition to that sleep state, the

   9:  * transition should be aborted.  Moreover, if such an event occurs when the

  10:  * system is in the working state, an attempt to start a transition to the

  11:  * given sleep state should fail during certain period after the detection of

  12:  * the event.  Using the 'state' attribute alone is not sufficient to satisfy

  13:  * these requirements, because a wakeup event may occur exactly when 'state'

  14:  * is being written to and may be delivered to user space right before it is

  15:  * frozen, so the event will remain only partially processed until the system is

  16:  * woken up by another event.  In particular, it won't cause the transition to

  17:  * a sleep state to be aborted.

  18:  *

  19:  * This difficulty may be overcome if user space uses 'wakeup_count' before

  20:  * writing to 'state'.  It first should read from 'wakeup_count' and store

  21:  * the read value.  Then, after carrying out its own preparations for the system

  22:  * transition to a sleep state, it should write the stored value to

  23:  * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since

  24:  * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it

  25:  * is allowed to write to 'state', but the transition will be aborted if there

  26:  * are any wakeup events detected after 'wakeup_count' was written to.

  27:  */

  28:  

  29: static ssize_t wakeup_count_show(struct kobject *kobj,

  30:                                 struct kobj_attribute *attr,

  31:                                 char *buf)

  32: {

  33:         unsigned int val;

  34:  

  35:         return pm_get_wakeup_count(&val, true) ?

  36:                 sprintf(buf, "%u\n", val) : -EINTR;

  37: }

  38:  

  39: static ssize_t wakeup_count_store(struct kobject *kobj,

  40:                                 struct kobj_attribute *attr,

  41:                                 const char *buf, size_t n)

  42: {

  43:         unsigned int val;

  44: int error;

  45:  

  46: error = pm_autosleep_lock();

  47: if (error)

  48:         return error;

  49:  

  50: if (pm_autosleep_state() > PM_SUSPEND_ON) {

  51:         error = -EBUSY;

  52:         goto out;

  53: }

  54:  

  55: error = -EINVAL;

  56: if (sscanf(buf, "%u", &val) == 1) {

  57:         if (pm_save_wakeup_count(val))

  58:                 error = n;

  59: }

  60:  

  61:  out:

  62: pm_autosleep_unlock();

  63: return error;

  64: }

  65:  

  66: tr(wakeup_count);

   1: bool pm_get_wakeup_count(unsigned int *count, bool block)

   2: {

   3:         unsigned int cnt, inpr;

   4:  

   5:         if (block) {

   6:                 DEFINE_WAIT(wait);

   7:  

   8:                 for (;;) {

   9:                         prepare_to_wait(&wakeup_count_wait_queue, &wait,

  10:                                         TASK_INTERRUPTIBLE);

  11:                         split_counters(&cnt, &inpr);

  12:                         if (inpr == 0 || signal_pending(current))

  13:                                 break;

  14:  

  15:                         schedule();

  16:                 }

  17:                 finish_wait(&wakeup_count_wait_queue, &wait);

  18:         }

  19:  

  20:         split_counters(&cnt, &inpr);

  21:         *count = cnt;

  22:         return !inpr;

  23: }

   1: bool pm_save_wakeup_count(unsigned int count)

   2: {

   3:         unsigned int cnt, inpr;

   4:         unsigned long flags;

   5:  

   6:         events_check_enabled = false;

   7:         spin_lock_irqsave(&events_lock, flags);

   8:         split_counters(&cnt, &inpr);

   9:         if (cnt == count && inpr == 0) {

  10:                 saved_count = count;

  11:                 events_check_enabled = true;

  12:         }

  13:         spin_unlock_irqrestore(&events_lock, flags);

  14:         return events_check_enabled;

  15: }

   1: static int suspend_enter(suspend_state_t state, bool *wakeup)

   2: {

   3:     ...

   4:     error = syscore_suspend();

   5:     if (!error) {

   6:         *wakeup = pm_wakeup_pending();

   7:         if (!(suspend_test(TEST_CORE) || *wakeup)) {

   8:                 error = suspend_ops->enter(state);

   9:                 events_check_enabled = false;

  10:         }

  11:         syscore_resume();

  12:     }

  13:     ...

  14: }

   1: bool pm_wakeup_pending(void)

   2: {

   3:         unsigned long flags;

   4:         bool ret = false;

   5:  

   6:         spin_lock_irqsave(&events_lock, flags);

   7:         if (events_check_enabled) {

   8:                 unsigned int cnt, inpr;

   9:  

  10:                 split_counters(&cnt, &inpr);

  11:                 ret = (cnt != saved_count || inpr > 0);

  12:                 events_check_enabled = !ret;

  13:         }

  14:         spin_unlock_irqrestore(&events_lock, flags);

  15:  

  16:         if (ret)

  17:                 print_active_wakeup_sources();

  18:  

  19:         return ret;

  20: }