mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-08-22 04:38:03 +03:00
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@16459 3c298f89-4303-0410-b956-a3cf2f4a3e73
674 lines
19 KiB
Diff
674 lines
19 KiB
Diff
From eef7f012d480142a3eccff91e0ae73ecb13220b3 Mon Sep 17 00:00:00 2001
|
|
From: =?utf-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
|
|
Date: Tue, 9 Sep 2008 22:14:34 -0700
|
|
Subject: [PATCH 066/134] PM: Implement wakelock api.
|
|
MIME-Version: 1.0
|
|
Content-Type: text/plain; charset=utf-8
|
|
Content-Transfer-Encoding: 8bit
|
|
|
|
PM: wakelock: Replace expire work with a timer
|
|
|
|
The expire work function did not work in the normal case.
|
|
|
|
Signed-off-by: Arve Hjønnevåg <arve@android.com>
|
|
---
|
|
kernel/power/Kconfig | 19 ++
|
|
kernel/power/Makefile | 1 +
|
|
kernel/power/power.h | 7 +
|
|
kernel/power/wakelock.c | 598 +++++++++++++++++++++++++++++++++++++++++++++++
|
|
4 files changed, 625 insertions(+), 0 deletions(-)
|
|
create mode 100644 kernel/power/wakelock.c
|
|
|
|
--- a/kernel/power/Kconfig
|
|
+++ b/kernel/power/Kconfig
|
|
@@ -116,6 +116,25 @@ config SUSPEND_FREEZER
|
|
|
|
Turning OFF this setting is NOT recommended! If in doubt, say Y.
|
|
|
|
+config HAS_WAKELOCK
|
|
+ bool
|
|
+
|
|
+config WAKELOCK
|
|
+ bool "Wake lock"
|
|
+ depends on PM && RTC_CLASS
|
|
+ default n
|
|
+ select HAS_WAKELOCK
|
|
+ ---help---
|
|
+ Enable wakelocks. When user space request a sleep state the
|
|
+ sleep request will be delayed until no wake locks are held.
|
|
+
|
|
+config WAKELOCK_STAT
|
|
+ bool "Wake lock stats"
|
|
+ depends on WAKELOCK
|
|
+ default y
|
|
+ ---help---
|
|
+ Report wake lock stats in /proc/wakelocks
|
|
+
|
|
config HIBERNATION
|
|
bool "Hibernation (aka 'suspend to disk')"
|
|
depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
|
|
--- a/kernel/power/Makefile
|
|
+++ b/kernel/power/Makefile
|
|
@@ -6,6 +6,7 @@ endif
|
|
obj-$(CONFIG_PM) += main.o
|
|
obj-$(CONFIG_PM_SLEEP) += console.o
|
|
obj-$(CONFIG_FREEZER) += process.o
|
|
+obj-$(CONFIG_WAKELOCK) += wakelock.o
|
|
obj-$(CONFIG_HIBERNATION) += swsusp.o disk.o snapshot.o swap.o user.o
|
|
|
|
obj-$(CONFIG_MAGIC_SYSRQ) += poweroff.o
|
|
--- a/kernel/power/power.h
|
|
+++ b/kernel/power/power.h
|
|
@@ -223,3 +223,10 @@ static inline void suspend_thaw_processe
|
|
{
|
|
}
|
|
#endif
|
|
+
|
|
+#ifdef CONFIG_WAKELOCK
|
|
+/* kernel/power/wakelock.c */
|
|
+extern struct workqueue_struct *suspend_work_queue;
|
|
+extern struct wake_lock main_wake_lock;
|
|
+extern suspend_state_t requested_suspend_state;
|
|
+#endif
|
|
--- /dev/null
|
|
+++ b/kernel/power/wakelock.c
|
|
@@ -0,0 +1,598 @@
|
|
+/* kernel/power/wakelock.c
|
|
+ *
|
|
+ * Copyright (C) 2005-2008 Google, Inc.
|
|
+ *
|
|
+ * This software is licensed under the terms of the GNU General Public
|
|
+ * License version 2, as published by the Free Software Foundation, and
|
|
+ * may be copied, distributed, and modified under those terms.
|
|
+ *
|
|
+ * 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.
|
|
+ *
|
|
+ */
|
|
+
|
|
+#include <linux/module.h>
|
|
+#include <linux/platform_device.h>
|
|
+#include <linux/rtc.h>
|
|
+#include <linux/suspend.h>
|
|
+#include <linux/syscalls.h> /* sys_sync */
|
|
+#include <linux/wakelock.h>
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+#include <linux/proc_fs.h>
|
|
+#endif
|
|
+#include "power.h"
|
|
+
|
|
+enum {
|
|
+ DEBUG_EXIT_SUSPEND = 1U << 0,
|
|
+ DEBUG_WAKEUP = 1U << 1,
|
|
+ DEBUG_SUSPEND = 1U << 2,
|
|
+ DEBUG_EXPIRE = 1U << 3,
|
|
+ DEBUG_WAKE_LOCK = 1U << 4,
|
|
+};
|
|
+static int debug_mask = DEBUG_EXIT_SUSPEND | DEBUG_WAKEUP;
|
|
+module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
|
|
+
|
|
+#define WAKE_LOCK_TYPE_MASK (0x0f)
|
|
+#define WAKE_LOCK_INITIALIZED (1U << 8)
|
|
+#define WAKE_LOCK_ACTIVE (1U << 9)
|
|
+#define WAKE_LOCK_AUTO_EXPIRE (1U << 10)
|
|
+#define WAKE_LOCK_PREVENTING_SUSPEND (1U << 11)
|
|
+
|
|
+static DEFINE_SPINLOCK(list_lock);
|
|
+static LIST_HEAD(inactive_locks);
|
|
+static struct list_head active_wake_locks[WAKE_LOCK_TYPE_COUNT];
|
|
+static int current_event_num;
|
|
+struct workqueue_struct *suspend_work_queue;
|
|
+struct wake_lock main_wake_lock;
|
|
+suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;
|
|
+static struct wake_lock unknown_wakeup;
|
|
+
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+static struct wake_lock deleted_wake_locks;
|
|
+static ktime_t last_sleep_time_update;
|
|
+static int wait_for_wakeup;
|
|
+
|
|
+int get_expired_time(struct wake_lock *lock, ktime_t *expire_time)
|
|
+{
|
|
+ struct timespec ts;
|
|
+ struct timespec kt;
|
|
+ struct timespec tomono;
|
|
+ struct timespec delta;
|
|
+ unsigned long seq;
|
|
+ long timeout;
|
|
+
|
|
+ if (!(lock->flags & WAKE_LOCK_AUTO_EXPIRE))
|
|
+ return 0;
|
|
+ do {
|
|
+ seq = read_seqbegin(&xtime_lock);
|
|
+ timeout = lock->expires - jiffies;
|
|
+ if (timeout > 0)
|
|
+ return 0;
|
|
+ kt = current_kernel_time();
|
|
+ tomono = wall_to_monotonic;
|
|
+ } while (read_seqretry(&xtime_lock, seq));
|
|
+ jiffies_to_timespec(-timeout, &delta);
|
|
+ set_normalized_timespec(&ts, kt.tv_sec + tomono.tv_sec - delta.tv_sec,
|
|
+ kt.tv_nsec + tomono.tv_nsec - delta.tv_nsec);
|
|
+ *expire_time = timespec_to_ktime(ts);
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+
|
|
+static int print_lock_stat(char *buf, struct wake_lock *lock)
|
|
+{
|
|
+ int lock_count = lock->stat.count;
|
|
+ int expire_count = lock->stat.expire_count;
|
|
+ ktime_t active_time = ktime_set(0, 0);
|
|
+ ktime_t total_time = lock->stat.total_time;
|
|
+ ktime_t max_time = lock->stat.max_time;
|
|
+ ktime_t prevent_suspend_time = lock->stat.prevent_suspend_time;
|
|
+ if (lock->flags & WAKE_LOCK_ACTIVE) {
|
|
+ ktime_t now, add_time;
|
|
+ int expired = get_expired_time(lock, &now);
|
|
+ if (!expired)
|
|
+ now = ktime_get();
|
|
+ add_time = ktime_sub(now, lock->stat.last_time);
|
|
+ lock_count++;
|
|
+ if (!expired)
|
|
+ active_time = add_time;
|
|
+ else
|
|
+ expire_count++;
|
|
+ total_time = ktime_add(total_time, add_time);
|
|
+ if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND)
|
|
+ prevent_suspend_time = ktime_add(prevent_suspend_time,
|
|
+ ktime_sub(now, last_sleep_time_update));
|
|
+ if (add_time.tv64 > max_time.tv64)
|
|
+ max_time = add_time;
|
|
+ }
|
|
+
|
|
+ return sprintf(buf, "\"%s\"\t%d\t%d\t%d\t%lld\t%lld\t%lld\t%lld\t"
|
|
+ "%lld\n", lock->name, lock_count, expire_count,
|
|
+ lock->stat.wakeup_count, ktime_to_ns(active_time),
|
|
+ ktime_to_ns(total_time),
|
|
+ ktime_to_ns(prevent_suspend_time), ktime_to_ns(max_time),
|
|
+ ktime_to_ns(lock->stat.last_time));
|
|
+}
|
|
+
|
|
+
|
|
+static int wakelocks_read_proc(char *page, char **start, off_t off,
|
|
+ int count, int *eof, void *data)
|
|
+{
|
|
+ unsigned long irqflags;
|
|
+ struct wake_lock *lock;
|
|
+ int len = 0;
|
|
+ char *p = page;
|
|
+ int type;
|
|
+
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+
|
|
+ p += sprintf(p, "name\tcount\texpire_count\twake_count\tactive_since"
|
|
+ "\ttotal_time\tsleep_time\tmax_time\tlast_change\n");
|
|
+ list_for_each_entry(lock, &inactive_locks, link) {
|
|
+ p += print_lock_stat(p, lock);
|
|
+ }
|
|
+ for (type = 0; type < WAKE_LOCK_TYPE_COUNT; type++) {
|
|
+ list_for_each_entry(lock, &active_wake_locks[type], link)
|
|
+ p += print_lock_stat(p, lock);
|
|
+ }
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+
|
|
+ *start = page + off;
|
|
+
|
|
+ len = p - page;
|
|
+ if (len > off)
|
|
+ len -= off;
|
|
+ else
|
|
+ len = 0;
|
|
+
|
|
+ return len < count ? len : count;
|
|
+}
|
|
+
|
|
+static void wake_unlock_stat_locked(struct wake_lock *lock, int expired)
|
|
+{
|
|
+ ktime_t duration;
|
|
+ ktime_t now;
|
|
+ if (!(lock->flags & WAKE_LOCK_ACTIVE))
|
|
+ return;
|
|
+ if (get_expired_time(lock, &now))
|
|
+ expired = 1;
|
|
+ else
|
|
+ now = ktime_get();
|
|
+ lock->stat.count++;
|
|
+ if (expired)
|
|
+ lock->stat.expire_count++;
|
|
+ duration = ktime_sub(now, lock->stat.last_time);
|
|
+ lock->stat.total_time = ktime_add(lock->stat.total_time, duration);
|
|
+ if (ktime_to_ns(duration) > ktime_to_ns(lock->stat.max_time))
|
|
+ lock->stat.max_time = duration;
|
|
+ lock->stat.last_time = ktime_get();
|
|
+ if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND) {
|
|
+ duration = ktime_sub(now, last_sleep_time_update);
|
|
+ lock->stat.prevent_suspend_time = ktime_add(
|
|
+ lock->stat.prevent_suspend_time, duration);
|
|
+ lock->flags &= ~WAKE_LOCK_PREVENTING_SUSPEND;
|
|
+ }
|
|
+}
|
|
+
|
|
+static void update_sleep_wait_stats_locked(int done)
|
|
+{
|
|
+ struct wake_lock *lock;
|
|
+ ktime_t now, etime, elapsed, add;
|
|
+ int expired;
|
|
+
|
|
+ now = ktime_get();
|
|
+ elapsed = ktime_sub(now, last_sleep_time_update);
|
|
+ list_for_each_entry(lock, &active_wake_locks[WAKE_LOCK_SUSPEND], link) {
|
|
+ expired = get_expired_time(lock, &etime);
|
|
+ if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND) {
|
|
+ if (expired)
|
|
+ add = ktime_sub(etime, last_sleep_time_update);
|
|
+ else
|
|
+ add = elapsed;
|
|
+ lock->stat.prevent_suspend_time = ktime_add(
|
|
+ lock->stat.prevent_suspend_time, add);
|
|
+ }
|
|
+ if (done || expired)
|
|
+ lock->flags &= ~WAKE_LOCK_PREVENTING_SUSPEND;
|
|
+ else
|
|
+ lock->flags |= WAKE_LOCK_PREVENTING_SUSPEND;
|
|
+ }
|
|
+ last_sleep_time_update = now;
|
|
+}
|
|
+#endif
|
|
+
|
|
+
|
|
+static void expire_wake_lock(struct wake_lock *lock)
|
|
+{
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ wake_unlock_stat_locked(lock, 1);
|
|
+#endif
|
|
+ lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);
|
|
+ list_del(&lock->link);
|
|
+ list_add(&lock->link, &inactive_locks);
|
|
+ if (debug_mask & (DEBUG_WAKE_LOCK | DEBUG_EXPIRE))
|
|
+ pr_info("expired wake lock %s\n", lock->name);
|
|
+}
|
|
+
|
|
+static void print_active_locks(int type)
|
|
+{
|
|
+ unsigned long irqflags;
|
|
+ struct wake_lock *lock;
|
|
+
|
|
+ BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ list_for_each_entry(lock, &active_wake_locks[type], link) {
|
|
+ if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {
|
|
+ long timeout = lock->expires - jiffies;
|
|
+ if (timeout <= 0)
|
|
+ pr_info("wake lock %s, expired\n", lock->name);
|
|
+ else
|
|
+ pr_info("active wake lock %s, time left %ld\n",
|
|
+ lock->name, timeout);
|
|
+ } else
|
|
+ pr_info("active wake lock %s\n", lock->name);
|
|
+ }
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+}
|
|
+
|
|
+static long has_wake_lock_locked(int type)
|
|
+{
|
|
+ struct wake_lock *lock, *n;
|
|
+ long max_timeout = 0;
|
|
+
|
|
+ BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
|
|
+ list_for_each_entry_safe(lock, n, &active_wake_locks[type], link) {
|
|
+ if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {
|
|
+ long timeout = lock->expires - jiffies;
|
|
+ if (timeout <= 0)
|
|
+ expire_wake_lock(lock);
|
|
+ else if (timeout > max_timeout)
|
|
+ max_timeout = timeout;
|
|
+ } else
|
|
+ return -1;
|
|
+ }
|
|
+ return max_timeout;
|
|
+}
|
|
+
|
|
+long has_wake_lock(int type)
|
|
+{
|
|
+ long ret;
|
|
+ unsigned long irqflags;
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ ret = has_wake_lock_locked(type);
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+static void suspend(struct work_struct *work)
|
|
+{
|
|
+ int ret;
|
|
+ int entry_event_num;
|
|
+
|
|
+ if (has_wake_lock(WAKE_LOCK_SUSPEND)) {
|
|
+ if (debug_mask & DEBUG_SUSPEND)
|
|
+ pr_info("suspend: abort suspend\n");
|
|
+ return;
|
|
+ }
|
|
+
|
|
+ entry_event_num = current_event_num;
|
|
+ sys_sync();
|
|
+ if (debug_mask & DEBUG_SUSPEND)
|
|
+ pr_info("suspend: enter suspend\n");
|
|
+ ret = pm_suspend(requested_suspend_state);
|
|
+ if (debug_mask & DEBUG_EXIT_SUSPEND) {
|
|
+ struct timespec ts;
|
|
+ struct rtc_time tm;
|
|
+ getnstimeofday(&ts);
|
|
+ rtc_time_to_tm(ts.tv_sec, &tm);
|
|
+ pr_info("suspend: exit suspend, ret = %d "
|
|
+ "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,
|
|
+ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
|
|
+ tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
|
|
+ }
|
|
+ if (current_event_num == entry_event_num) {
|
|
+ if (debug_mask & DEBUG_SUSPEND)
|
|
+ pr_info("suspend: pm_suspend returned with no event\n");
|
|
+ wake_lock_timeout(&unknown_wakeup, HZ / 2);
|
|
+ }
|
|
+}
|
|
+static DECLARE_WORK(suspend_work, suspend);
|
|
+
|
|
+static void expire_wake_locks(unsigned long data)
|
|
+{
|
|
+ long has_lock;
|
|
+ unsigned long irqflags;
|
|
+ if (debug_mask & DEBUG_EXPIRE)
|
|
+ pr_info("expire_wake_locks: start\n");
|
|
+ if (debug_mask & DEBUG_SUSPEND)
|
|
+ print_active_locks(WAKE_LOCK_SUSPEND);
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ has_lock = has_wake_lock_locked(WAKE_LOCK_SUSPEND);
|
|
+ if (debug_mask & DEBUG_EXPIRE)
|
|
+ pr_info("expire_wake_locks: done, has_lock %ld\n", has_lock);
|
|
+ if (has_lock == 0)
|
|
+ queue_work(suspend_work_queue, &suspend_work);
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+}
|
|
+static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0);
|
|
+
|
|
+static int power_suspend_late(struct platform_device *pdev, pm_message_t state)
|
|
+{
|
|
+ int ret = has_wake_lock(WAKE_LOCK_SUSPEND) ? -EAGAIN : 0;
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ wait_for_wakeup = 1;
|
|
+#endif
|
|
+ if (debug_mask & DEBUG_SUSPEND)
|
|
+ pr_info("power_suspend_late return %d\n", ret);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+static struct platform_driver power_driver = {
|
|
+ .driver.name = "power",
|
|
+ .suspend_late = power_suspend_late,
|
|
+};
|
|
+static struct platform_device power_device = {
|
|
+ .name = "power",
|
|
+};
|
|
+
|
|
+void wake_lock_init(struct wake_lock *lock, int type, const char *name)
|
|
+{
|
|
+ unsigned long irqflags = 0;
|
|
+
|
|
+ if (name)
|
|
+ lock->name = name;
|
|
+ BUG_ON(!lock->name);
|
|
+
|
|
+ if (debug_mask & DEBUG_WAKE_LOCK)
|
|
+ pr_info("wake_lock_init name=%s\n", lock->name);
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ lock->stat.count = 0;
|
|
+ lock->stat.expire_count = 0;
|
|
+ lock->stat.wakeup_count = 0;
|
|
+ lock->stat.total_time = ktime_set(0, 0);
|
|
+ lock->stat.prevent_suspend_time = ktime_set(0, 0);
|
|
+ lock->stat.max_time = ktime_set(0, 0);
|
|
+ lock->stat.last_time = ktime_set(0, 0);
|
|
+#endif
|
|
+ lock->flags = (type & WAKE_LOCK_TYPE_MASK) | WAKE_LOCK_INITIALIZED;
|
|
+
|
|
+ INIT_LIST_HEAD(&lock->link);
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ list_add(&lock->link, &inactive_locks);
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+}
|
|
+EXPORT_SYMBOL(wake_lock_init);
|
|
+
|
|
+void wake_lock_destroy(struct wake_lock *lock)
|
|
+{
|
|
+ unsigned long irqflags;
|
|
+ if (debug_mask & DEBUG_WAKE_LOCK)
|
|
+ pr_info("wake_lock_destroy name=%s\n", lock->name);
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ lock->flags &= ~WAKE_LOCK_INITIALIZED;
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ if (lock->stat.count) {
|
|
+ deleted_wake_locks.stat.count += lock->stat.count;
|
|
+ deleted_wake_locks.stat.expire_count += lock->stat.expire_count;
|
|
+ deleted_wake_locks.stat.total_time =
|
|
+ ktime_add(deleted_wake_locks.stat.total_time,
|
|
+ lock->stat.total_time);
|
|
+ deleted_wake_locks.stat.prevent_suspend_time =
|
|
+ ktime_add(deleted_wake_locks.stat.prevent_suspend_time,
|
|
+ lock->stat.prevent_suspend_time);
|
|
+ deleted_wake_locks.stat.max_time =
|
|
+ ktime_add(deleted_wake_locks.stat.max_time,
|
|
+ lock->stat.max_time);
|
|
+ }
|
|
+#endif
|
|
+ list_del(&lock->link);
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+}
|
|
+EXPORT_SYMBOL(wake_lock_destroy);
|
|
+
|
|
+static void wake_lock_internal(
|
|
+ struct wake_lock *lock, long timeout, int has_timeout)
|
|
+{
|
|
+ int type;
|
|
+ unsigned long irqflags;
|
|
+ long expire_in;
|
|
+
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ type = lock->flags & WAKE_LOCK_TYPE_MASK;
|
|
+ BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
|
|
+ BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {
|
|
+ if (debug_mask & DEBUG_WAKEUP)
|
|
+ pr_info("wakeup wake lock: %s\n", lock->name);
|
|
+ wait_for_wakeup = 0;
|
|
+ lock->stat.wakeup_count++;
|
|
+ }
|
|
+ if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&
|
|
+ (long)(lock->expires - jiffies) <= 0) {
|
|
+ wake_unlock_stat_locked(lock, 0);
|
|
+ lock->stat.last_time = ktime_get();
|
|
+ }
|
|
+#endif
|
|
+ if (!(lock->flags & WAKE_LOCK_ACTIVE)) {
|
|
+ lock->flags |= WAKE_LOCK_ACTIVE;
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ lock->stat.last_time = ktime_get();
|
|
+#endif
|
|
+ }
|
|
+ list_del(&lock->link);
|
|
+ if (has_timeout) {
|
|
+ if (debug_mask & DEBUG_WAKE_LOCK)
|
|
+ pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",
|
|
+ lock->name, type, timeout / HZ,
|
|
+ (timeout % HZ) * MSEC_PER_SEC / HZ);
|
|
+ lock->expires = jiffies + timeout;
|
|
+ lock->flags |= WAKE_LOCK_AUTO_EXPIRE;
|
|
+ list_add_tail(&lock->link, &active_wake_locks[type]);
|
|
+ } else {
|
|
+ if (debug_mask & DEBUG_WAKE_LOCK)
|
|
+ pr_info("wake_lock: %s, type %d\n", lock->name, type);
|
|
+ lock->expires = LONG_MAX;
|
|
+ lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;
|
|
+ list_add(&lock->link, &active_wake_locks[type]);
|
|
+ }
|
|
+ if (type == WAKE_LOCK_SUSPEND) {
|
|
+ current_event_num++;
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ if (lock == &main_wake_lock)
|
|
+ update_sleep_wait_stats_locked(1);
|
|
+ else if (!wake_lock_active(&main_wake_lock))
|
|
+ update_sleep_wait_stats_locked(0);
|
|
+#endif
|
|
+ if (has_timeout)
|
|
+ expire_in = has_wake_lock_locked(type);
|
|
+ else
|
|
+ expire_in = -1;
|
|
+ if (expire_in > 0) {
|
|
+ if (debug_mask & DEBUG_EXPIRE)
|
|
+ pr_info("wake_lock: %s, start expire timer, "
|
|
+ "%ld\n", lock->name, expire_in);
|
|
+ mod_timer(&expire_timer, jiffies + expire_in);
|
|
+ } else {
|
|
+ if (del_timer(&expire_timer))
|
|
+ if (debug_mask & DEBUG_EXPIRE)
|
|
+ pr_info("wake_lock: %s, stop expire timer\n",
|
|
+ lock->name);
|
|
+ if (expire_in == 0)
|
|
+ queue_work(suspend_work_queue, &suspend_work);
|
|
+ }
|
|
+ }
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+}
|
|
+
|
|
+void wake_lock(struct wake_lock *lock)
|
|
+{
|
|
+ wake_lock_internal(lock, 0, 0);
|
|
+}
|
|
+EXPORT_SYMBOL(wake_lock);
|
|
+
|
|
+void wake_lock_timeout(struct wake_lock *lock, long timeout)
|
|
+{
|
|
+ wake_lock_internal(lock, timeout, 1);
|
|
+}
|
|
+EXPORT_SYMBOL(wake_lock_timeout);
|
|
+
|
|
+void wake_unlock(struct wake_lock *lock)
|
|
+{
|
|
+ int type;
|
|
+ unsigned long irqflags;
|
|
+ spin_lock_irqsave(&list_lock, irqflags);
|
|
+ type = lock->flags & WAKE_LOCK_TYPE_MASK;
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ wake_unlock_stat_locked(lock, 0);
|
|
+#endif
|
|
+ if (debug_mask & DEBUG_WAKE_LOCK)
|
|
+ pr_info("wake_unlock: %s\n", lock->name);
|
|
+ lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);
|
|
+ list_del(&lock->link);
|
|
+ list_add(&lock->link, &inactive_locks);
|
|
+ if (type == WAKE_LOCK_SUSPEND) {
|
|
+ long has_lock = has_wake_lock_locked(type);
|
|
+ if (has_lock > 0) {
|
|
+ if (debug_mask & DEBUG_EXPIRE)
|
|
+ pr_info("wake_unlock: %s, start expire timer, "
|
|
+ "%ld\n", lock->name, has_lock);
|
|
+ mod_timer(&expire_timer, jiffies + has_lock);
|
|
+ } else {
|
|
+ if (del_timer(&expire_timer))
|
|
+ if (debug_mask & DEBUG_EXPIRE)
|
|
+ pr_info("wake_unlock: %s, stop expire "
|
|
+ "timer\n", lock->name);
|
|
+ if (has_lock == 0)
|
|
+ queue_work(suspend_work_queue, &suspend_work);
|
|
+ }
|
|
+ if (lock == &main_wake_lock) {
|
|
+ if (debug_mask & DEBUG_SUSPEND)
|
|
+ print_active_locks(WAKE_LOCK_SUSPEND);
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ update_sleep_wait_stats_locked(0);
|
|
+#endif
|
|
+ }
|
|
+ }
|
|
+ spin_unlock_irqrestore(&list_lock, irqflags);
|
|
+}
|
|
+EXPORT_SYMBOL(wake_unlock);
|
|
+
|
|
+int wake_lock_active(struct wake_lock *lock)
|
|
+{
|
|
+ return !!(lock->flags & WAKE_LOCK_ACTIVE);
|
|
+}
|
|
+EXPORT_SYMBOL(wake_lock_active);
|
|
+
|
|
+static int __init wakelocks_init(void)
|
|
+{
|
|
+ int ret;
|
|
+ int i;
|
|
+
|
|
+ for (i = 0; i < ARRAY_SIZE(active_wake_locks); i++)
|
|
+ INIT_LIST_HEAD(&active_wake_locks[i]);
|
|
+
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,
|
|
+ "deleted_wake_locks");
|
|
+#endif
|
|
+ wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "main");
|
|
+ wake_lock(&main_wake_lock);
|
|
+ wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");
|
|
+
|
|
+ ret = platform_device_register(&power_device);
|
|
+ if (ret) {
|
|
+ pr_err("wakelocks_init: platform_device_register failed\n");
|
|
+ goto err_platform_device_register;
|
|
+ }
|
|
+ ret = platform_driver_register(&power_driver);
|
|
+ if (ret) {
|
|
+ pr_err("wakelocks_init: platform_driver_register failed\n");
|
|
+ goto err_platform_driver_register;
|
|
+ }
|
|
+
|
|
+ suspend_work_queue = create_singlethread_workqueue("suspend");
|
|
+ if (suspend_work_queue == NULL) {
|
|
+ ret = -ENOMEM;
|
|
+ goto err_suspend_work_queue;
|
|
+ }
|
|
+
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ create_proc_read_entry("wakelocks", S_IRUGO, NULL,
|
|
+ wakelocks_read_proc, NULL);
|
|
+#endif
|
|
+
|
|
+ return 0;
|
|
+
|
|
+err_suspend_work_queue:
|
|
+ platform_driver_unregister(&power_driver);
|
|
+err_platform_driver_register:
|
|
+ platform_device_unregister(&power_device);
|
|
+err_platform_device_register:
|
|
+ wake_lock_destroy(&unknown_wakeup);
|
|
+ wake_lock_destroy(&main_wake_lock);
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ wake_lock_destroy(&deleted_wake_locks);
|
|
+#endif
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+static void __exit wakelocks_exit(void)
|
|
+{
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ remove_proc_entry("wakelocks", NULL);
|
|
+#endif
|
|
+ destroy_workqueue(suspend_work_queue);
|
|
+ platform_driver_unregister(&power_driver);
|
|
+ platform_device_unregister(&power_device);
|
|
+ wake_lock_destroy(&unknown_wakeup);
|
|
+ wake_lock_destroy(&main_wake_lock);
|
|
+#ifdef CONFIG_WAKELOCK_STAT
|
|
+ wake_lock_destroy(&deleted_wake_locks);
|
|
+#endif
|
|
+}
|
|
+
|
|
+core_initcall(wakelocks_init);
|
|
+module_exit(wakelocks_exit);
|