diff options
author | Felix Fietkau <nbd@openwrt.org> | 2009-06-14 20:42:33 +0000 |
---|---|---|
committer | Felix Fietkau <nbd@openwrt.org> | 2009-06-14 20:42:33 +0000 |
commit | 2d5f80251c73e1e44c8fdd047ef49dbe051d65aa (patch) | |
tree | 74597f2d6eef2e7a6d6338c978b8910f9f947151 /target/linux/goldfish/patches-2.6.30/0066-PM-Implement-wakelock-api.patch | |
parent | 157a4ab64660aaca2dd51fa4f82239d3738a1dff (diff) | |
download | master-187ad058-2d5f80251c73e1e44c8fdd047ef49dbe051d65aa.tar.gz master-187ad058-2d5f80251c73e1e44c8fdd047ef49dbe051d65aa.tar.bz2 master-187ad058-2d5f80251c73e1e44c8fdd047ef49dbe051d65aa.zip |
add the 'goldfish' target, useful for experimenting with virtual phone hardware (includes the emulator)
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@16459 3c298f89-4303-0410-b956-a3cf2f4a3e73
Diffstat (limited to 'target/linux/goldfish/patches-2.6.30/0066-PM-Implement-wakelock-api.patch')
-rw-r--r-- | target/linux/goldfish/patches-2.6.30/0066-PM-Implement-wakelock-api.patch | 673 |
1 files changed, 673 insertions, 0 deletions
diff --git a/target/linux/goldfish/patches-2.6.30/0066-PM-Implement-wakelock-api.patch b/target/linux/goldfish/patches-2.6.30/0066-PM-Implement-wakelock-api.patch new file mode 100644 index 0000000000..610bc1f518 --- /dev/null +++ b/target/linux/goldfish/patches-2.6.30/0066-PM-Implement-wakelock-api.patch @@ -0,0 +1,673 @@ +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); |