add the 'goldfish' target, useful for experimenting with virtual phone hardware ...
[openwrt/svn-archive/archive.git] / target / linux / goldfish / patches-2.6.30 / 0067-PM-Implement-early-suspend-api.patch
1 From 2d4a25785ad1aa51bad967543e1ab20e9ed4a046 Mon Sep 17 00:00:00 2001
2 From: =?utf-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
3 Date: Tue, 7 Oct 2008 20:48:01 -0700
4 Subject: [PATCH 067/134] PM: Implement early suspend api
5
6 ---
7 kernel/power/Kconfig | 12 +++
8 kernel/power/Makefile | 1 +
9 kernel/power/earlysuspend.c | 178 +++++++++++++++++++++++++++++++++++++++++++
10 kernel/power/power.h | 6 ++
11 4 files changed, 197 insertions(+), 0 deletions(-)
12 create mode 100644 kernel/power/earlysuspend.c
13
14 --- a/kernel/power/Kconfig
15 +++ b/kernel/power/Kconfig
16 @@ -119,6 +119,9 @@ config SUSPEND_FREEZER
17 config HAS_WAKELOCK
18 bool
19
20 +config HAS_EARLYSUSPEND
21 + bool
22 +
23 config WAKELOCK
24 bool "Wake lock"
25 depends on PM && RTC_CLASS
26 @@ -135,6 +138,15 @@ config WAKELOCK_STAT
27 ---help---
28 Report wake lock stats in /proc/wakelocks
29
30 +config EARLYSUSPEND
31 + bool "Early suspend"
32 + depends on WAKELOCK
33 + default y
34 + select HAS_EARLYSUSPEND
35 + ---help---
36 + Call early suspend handlers when the user requested sleep state
37 + changes.
38 +
39 config HIBERNATION
40 bool "Hibernation (aka 'suspend to disk')"
41 depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
42 --- a/kernel/power/Makefile
43 +++ b/kernel/power/Makefile
44 @@ -7,6 +7,7 @@ obj-$(CONFIG_PM) += main.o
45 obj-$(CONFIG_PM_SLEEP) += console.o
46 obj-$(CONFIG_FREEZER) += process.o
47 obj-$(CONFIG_WAKELOCK) += wakelock.o
48 +obj-$(CONFIG_EARLYSUSPEND) += earlysuspend.o
49 obj-$(CONFIG_HIBERNATION) += swsusp.o disk.o snapshot.o swap.o user.o
50
51 obj-$(CONFIG_MAGIC_SYSRQ) += poweroff.o
52 --- /dev/null
53 +++ b/kernel/power/earlysuspend.c
54 @@ -0,0 +1,178 @@
55 +/* kernel/power/earlysuspend.c
56 + *
57 + * Copyright (C) 2005-2008 Google, Inc.
58 + *
59 + * This software is licensed under the terms of the GNU General Public
60 + * License version 2, as published by the Free Software Foundation, and
61 + * may be copied, distributed, and modified under those terms.
62 + *
63 + * This program is distributed in the hope that it will be useful,
64 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
65 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
66 + * GNU General Public License for more details.
67 + *
68 + */
69 +
70 +#include <linux/earlysuspend.h>
71 +#include <linux/module.h>
72 +#include <linux/mutex.h>
73 +#include <linux/rtc.h>
74 +#include <linux/syscalls.h> /* sys_sync */
75 +#include <linux/wakelock.h>
76 +#include <linux/workqueue.h>
77 +
78 +#include "power.h"
79 +
80 +enum {
81 + DEBUG_USER_STATE = 1U << 0,
82 + DEBUG_SUSPEND = 1U << 2,
83 +};
84 +static int debug_mask = DEBUG_USER_STATE;
85 +module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
86 +
87 +static DEFINE_MUTEX(early_suspend_lock);
88 +static LIST_HEAD(early_suspend_handlers);
89 +static void early_suspend(struct work_struct *work);
90 +static void late_resume(struct work_struct *work);
91 +static DECLARE_WORK(early_suspend_work, early_suspend);
92 +static DECLARE_WORK(late_resume_work, late_resume);
93 +static DEFINE_SPINLOCK(state_lock);
94 +enum {
95 + SUSPEND_REQUESTED = 0x1,
96 + SUSPENDED = 0x2,
97 + SUSPEND_REQUESTED_AND_SUSPENDED = SUSPEND_REQUESTED | SUSPENDED,
98 +};
99 +static int state;
100 +
101 +void register_early_suspend(struct early_suspend *handler)
102 +{
103 + struct list_head *pos;
104 +
105 + mutex_lock(&early_suspend_lock);
106 + list_for_each(pos, &early_suspend_handlers) {
107 + struct early_suspend *e;
108 + e = list_entry(pos, struct early_suspend, link);
109 + if (e->level > handler->level)
110 + break;
111 + }
112 + list_add_tail(&handler->link, pos);
113 + if ((state & SUSPENDED) && handler->suspend)
114 + handler->suspend(handler);
115 + mutex_unlock(&early_suspend_lock);
116 +}
117 +EXPORT_SYMBOL(register_early_suspend);
118 +
119 +void unregister_early_suspend(struct early_suspend *handler)
120 +{
121 + mutex_lock(&early_suspend_lock);
122 + list_del(&handler->link);
123 + mutex_unlock(&early_suspend_lock);
124 +}
125 +EXPORT_SYMBOL(unregister_early_suspend);
126 +
127 +static void early_suspend(struct work_struct *work)
128 +{
129 + struct early_suspend *pos;
130 + unsigned long irqflags;
131 + int abort = 0;
132 +
133 + mutex_lock(&early_suspend_lock);
134 + spin_lock_irqsave(&state_lock, irqflags);
135 + if (state == SUSPEND_REQUESTED)
136 + state |= SUSPENDED;
137 + else
138 + abort = 1;
139 + spin_unlock_irqrestore(&state_lock, irqflags);
140 +
141 + if (abort) {
142 + if (debug_mask & DEBUG_SUSPEND)
143 + pr_info("early_suspend: abort, state %d\n", state);
144 + mutex_unlock(&early_suspend_lock);
145 + goto abort;
146 + }
147 +
148 + if (debug_mask & DEBUG_SUSPEND)
149 + pr_info("early_suspend: call handlers\n");
150 + list_for_each_entry(pos, &early_suspend_handlers, link) {
151 + if (pos->suspend != NULL)
152 + pos->suspend(pos);
153 + }
154 + mutex_unlock(&early_suspend_lock);
155 +
156 + if (debug_mask & DEBUG_SUSPEND)
157 + pr_info("early_suspend: sync\n");
158 +
159 + sys_sync();
160 +abort:
161 + spin_lock_irqsave(&state_lock, irqflags);
162 + if (state == SUSPEND_REQUESTED_AND_SUSPENDED)
163 + wake_unlock(&main_wake_lock);
164 + spin_unlock_irqrestore(&state_lock, irqflags);
165 +}
166 +
167 +static void late_resume(struct work_struct *work)
168 +{
169 + struct early_suspend *pos;
170 + unsigned long irqflags;
171 + int abort = 0;
172 +
173 + mutex_lock(&early_suspend_lock);
174 + spin_lock_irqsave(&state_lock, irqflags);
175 + if (state == SUSPENDED)
176 + state &= ~SUSPENDED;
177 + else
178 + abort = 1;
179 + spin_unlock_irqrestore(&state_lock, irqflags);
180 +
181 + if (abort) {
182 + if (debug_mask & DEBUG_SUSPEND)
183 + pr_info("late_resume: abort, state %d\n", state);
184 + goto abort;
185 + }
186 + if (debug_mask & DEBUG_SUSPEND)
187 + pr_info("late_resume: call handlers\n");
188 + list_for_each_entry_reverse(pos, &early_suspend_handlers, link)
189 + if (pos->resume != NULL)
190 + pos->resume(pos);
191 + if (debug_mask & DEBUG_SUSPEND)
192 + pr_info("late_resume: done\n");
193 +abort:
194 + mutex_unlock(&early_suspend_lock);
195 +}
196 +
197 +void request_suspend_state(suspend_state_t new_state)
198 +{
199 + unsigned long irqflags;
200 + int old_sleep;
201 +
202 + spin_lock_irqsave(&state_lock, irqflags);
203 + old_sleep = state & SUSPEND_REQUESTED;
204 + if (debug_mask & DEBUG_USER_STATE) {
205 + struct timespec ts;
206 + struct rtc_time tm;
207 + getnstimeofday(&ts);
208 + rtc_time_to_tm(ts.tv_sec, &tm);
209 + pr_info("request_suspend_state: %s (%d->%d) at %lld "
210 + "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
211 + new_state != PM_SUSPEND_ON ? "sleep" : "wakeup",
212 + requested_suspend_state, new_state,
213 + ktime_to_ns(ktime_get()),
214 + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
215 + tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
216 + }
217 + if (!old_sleep && new_state != PM_SUSPEND_ON) {
218 + state |= SUSPEND_REQUESTED;
219 + queue_work(suspend_work_queue, &early_suspend_work);
220 + } else if (old_sleep && new_state == PM_SUSPEND_ON) {
221 + state &= ~SUSPEND_REQUESTED;
222 + wake_lock(&main_wake_lock);
223 + queue_work(suspend_work_queue, &late_resume_work);
224 + }
225 + requested_suspend_state = new_state;
226 + spin_unlock_irqrestore(&state_lock, irqflags);
227 +}
228 +
229 +suspend_state_t get_suspend_state(void)
230 +{
231 + return requested_suspend_state;
232 +}
233 --- a/kernel/power/power.h
234 +++ b/kernel/power/power.h
235 @@ -230,3 +230,9 @@ extern struct workqueue_struct *suspend_
236 extern struct wake_lock main_wake_lock;
237 extern suspend_state_t requested_suspend_state;
238 #endif
239 +
240 +#ifdef CONFIG_EARLYSUSPEND
241 +/* kernel/power/earlysuspend.c */
242 +void request_suspend_state(suspend_state_t state);
243 +suspend_state_t get_suspend_state(void);
244 +#endif