Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 97740400bc76b64781d01f8cdfbcf750582006ef

Authored by Linus Torvalds 2012-01-17 07:02:30 +0800

Exists in master and in 6 other branches

Merge branch 'pm-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

* 'pm-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
  PM / Hibernate: Drop the check of swap space size for compressed image
  PM / shmobile: fix A3SP suspend method
  PM / Domains: Skip governor functions for CONFIG_PM_RUNTIME unset
  PM / Domains: Fix build for CONFIG_PM_SLEEP unset
  PM: Make sysrq-o be available for CONFIG_PM unset

Showing 5 changed files Inline Diff

arch/arm/mach-shmobile/pm-sh7372.c
drivers/base/power/domain.c
drivers/base/power/domain_governor.c
kernel/Makefile
kernel/power/swap.c

arch/arm/mach-shmobile/pm-sh7372.c

Diff comments View file @ 9774040

1	/*	1	/*
2	* sh7372 Power management support	2	* sh7372 Power management support
3	*	3	*
4	* Copyright (C) 2011 Magnus Damm	4	* Copyright (C) 2011 Magnus Damm
5	*	5	*
6	* This file is subject to the terms and conditions of the GNU General Public	6	* This file is subject to the terms and conditions of the GNU General Public
7	* License. See the file "COPYING" in the main directory of this archive	7	* License. See the file "COPYING" in the main directory of this archive
8	* for more details.	8	* for more details.
9	*/	9	*/
10		10
11	#include <linux/pm.h>	11	#include <linux/pm.h>
12	#include <linux/suspend.h>	12	#include <linux/suspend.h>
13	#include <linux/cpuidle.h>	13	#include <linux/cpuidle.h>
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/list.h>	15	#include <linux/list.h>
16	#include <linux/err.h>	16	#include <linux/err.h>
17	#include <linux/slab.h>	17	#include <linux/slab.h>
18	#include <linux/pm_clock.h>	18	#include <linux/pm_clock.h>
19	#include <linux/platform_device.h>	19	#include <linux/platform_device.h>
20	#include <linux/delay.h>	20	#include <linux/delay.h>
21	#include <linux/irq.h>	21	#include <linux/irq.h>
22	#include <linux/bitrev.h>	22	#include <linux/bitrev.h>
23	#include <linux/console.h>	23	#include <linux/console.h>
24	#include <asm/system.h>	24	#include <asm/system.h>
25	#include <asm/io.h>	25	#include <asm/io.h>
26	#include <asm/tlbflush.h>	26	#include <asm/tlbflush.h>
27	#include <asm/suspend.h>	27	#include <asm/suspend.h>
28	#include <mach/common.h>	28	#include <mach/common.h>
29	#include <mach/sh7372.h>	29	#include <mach/sh7372.h>
30		30
31	/* DBG */	31	/* DBG */
32	#define DBGREG1 0xe6100020	32	#define DBGREG1 0xe6100020
33	#define DBGREG9 0xe6100040	33	#define DBGREG9 0xe6100040
34		34
35	/* CPGA */	35	/* CPGA */
36	#define SYSTBCR 0xe6150024	36	#define SYSTBCR 0xe6150024
37	#define MSTPSR0 0xe6150030	37	#define MSTPSR0 0xe6150030
38	#define MSTPSR1 0xe6150038	38	#define MSTPSR1 0xe6150038
39	#define MSTPSR2 0xe6150040	39	#define MSTPSR2 0xe6150040
40	#define MSTPSR3 0xe6150048	40	#define MSTPSR3 0xe6150048
41	#define MSTPSR4 0xe615004c	41	#define MSTPSR4 0xe615004c
42	#define PLLC01STPCR 0xe61500c8	42	#define PLLC01STPCR 0xe61500c8
43		43
44	/* SYSC */	44	/* SYSC */
45	#define SPDCR 0xe6180008	45	#define SPDCR 0xe6180008
46	#define SWUCR 0xe6180014	46	#define SWUCR 0xe6180014
47	#define SBAR 0xe6180020	47	#define SBAR 0xe6180020
48	#define WUPRMSK 0xe6180028	48	#define WUPRMSK 0xe6180028
49	#define WUPSMSK 0xe618002c	49	#define WUPSMSK 0xe618002c
50	#define WUPSMSK2 0xe6180048	50	#define WUPSMSK2 0xe6180048
51	#define PSTR 0xe6180080	51	#define PSTR 0xe6180080
52	#define WUPSFAC 0xe6180098	52	#define WUPSFAC 0xe6180098
53	#define IRQCR 0xe618022c	53	#define IRQCR 0xe618022c
54	#define IRQCR2 0xe6180238	54	#define IRQCR2 0xe6180238
55	#define IRQCR3 0xe6180244	55	#define IRQCR3 0xe6180244
56	#define IRQCR4 0xe6180248	56	#define IRQCR4 0xe6180248
57	#define PDNSEL 0xe6180254	57	#define PDNSEL 0xe6180254
58		58
59	/* INTC */	59	/* INTC */
60	#define ICR1A 0xe6900000	60	#define ICR1A 0xe6900000
61	#define ICR2A 0xe6900004	61	#define ICR2A 0xe6900004
62	#define ICR3A 0xe6900008	62	#define ICR3A 0xe6900008
63	#define ICR4A 0xe690000c	63	#define ICR4A 0xe690000c
64	#define INTMSK00A 0xe6900040	64	#define INTMSK00A 0xe6900040
65	#define INTMSK10A 0xe6900044	65	#define INTMSK10A 0xe6900044
66	#define INTMSK20A 0xe6900048	66	#define INTMSK20A 0xe6900048
67	#define INTMSK30A 0xe690004c	67	#define INTMSK30A 0xe690004c
68		68
69	/* MFIS */	69	/* MFIS */
70	#define SMFRAM 0xe6a70000	70	#define SMFRAM 0xe6a70000
71		71
72	/* AP-System Core */	72	/* AP-System Core */
73	#define APARMBAREA 0xe6f10020	73	#define APARMBAREA 0xe6f10020
74		74
75	#define PSTR_RETRIES 100	75	#define PSTR_RETRIES 100
76	#define PSTR_DELAY_US 10	76	#define PSTR_DELAY_US 10
77		77
78	#ifdef CONFIG_PM	78	#ifdef CONFIG_PM
79		79
80	static int pd_power_down(struct generic_pm_domain *genpd)	80	static int pd_power_down(struct generic_pm_domain *genpd)
81	{	81	{
82	struct sh7372_pm_domain *sh7372_pd = to_sh7372_pd(genpd);	82	struct sh7372_pm_domain *sh7372_pd = to_sh7372_pd(genpd);
83	unsigned int mask = 1 << sh7372_pd->bit_shift;	83	unsigned int mask = 1 << sh7372_pd->bit_shift;
84		84
85	if (sh7372_pd->suspend) {	85	if (sh7372_pd->suspend) {
86	int ret = sh7372_pd->suspend();	86	int ret = sh7372_pd->suspend();
87		87
88	if (ret)	88	if (ret)
89	return ret;	89	return ret;
90	}	90	}
91		91
92	if (__raw_readl(PSTR) & mask) {	92	if (__raw_readl(PSTR) & mask) {
93	unsigned int retry_count;	93	unsigned int retry_count;
94		94
95	__raw_writel(mask, SPDCR);	95	__raw_writel(mask, SPDCR);
96		96
97	for (retry_count = PSTR_RETRIES; retry_count; retry_count--) {	97	for (retry_count = PSTR_RETRIES; retry_count; retry_count--) {
98	if (!(__raw_readl(SPDCR) & mask))	98	if (!(__raw_readl(SPDCR) & mask))
99	break;	99	break;
100	cpu_relax();	100	cpu_relax();
101	}	101	}
102	}	102	}
103		103
104	if (!sh7372_pd->no_debug)	104	if (!sh7372_pd->no_debug)
105	pr_debug("%s: Power off, 0x%08x -> PSTR = 0x%08x\n",	105	pr_debug("%s: Power off, 0x%08x -> PSTR = 0x%08x\n",
106	genpd->name, mask, __raw_readl(PSTR));	106	genpd->name, mask, __raw_readl(PSTR));
107		107
108	return 0;	108	return 0;
109	}	109	}
110		110
111	static int __pd_power_up(struct sh7372_pm_domain *sh7372_pd, bool do_resume)	111	static int __pd_power_up(struct sh7372_pm_domain *sh7372_pd, bool do_resume)
112	{	112	{
113	unsigned int mask = 1 << sh7372_pd->bit_shift;	113	unsigned int mask = 1 << sh7372_pd->bit_shift;
114	unsigned int retry_count;	114	unsigned int retry_count;
115	int ret = 0;	115	int ret = 0;
116		116
117	if (__raw_readl(PSTR) & mask)	117	if (__raw_readl(PSTR) & mask)
118	goto out;	118	goto out;
119		119
120	__raw_writel(mask, SWUCR);	120	__raw_writel(mask, SWUCR);
121		121
122	for (retry_count = 2 * PSTR_RETRIES; retry_count; retry_count--) {	122	for (retry_count = 2 * PSTR_RETRIES; retry_count; retry_count--) {
123	if (!(__raw_readl(SWUCR) & mask))	123	if (!(__raw_readl(SWUCR) & mask))
124	break;	124	break;
125	if (retry_count > PSTR_RETRIES)	125	if (retry_count > PSTR_RETRIES)
126	udelay(PSTR_DELAY_US);	126	udelay(PSTR_DELAY_US);
127	else	127	else
128	cpu_relax();	128	cpu_relax();
129	}	129	}
130	if (!retry_count)	130	if (!retry_count)
131	ret = -EIO;	131	ret = -EIO;
132		132
133	if (!sh7372_pd->no_debug)	133	if (!sh7372_pd->no_debug)
134	pr_debug("%s: Power on, 0x%08x -> PSTR = 0x%08x\n",	134	pr_debug("%s: Power on, 0x%08x -> PSTR = 0x%08x\n",
135	sh7372_pd->genpd.name, mask, __raw_readl(PSTR));	135	sh7372_pd->genpd.name, mask, __raw_readl(PSTR));
136		136
137	out:	137	out:
138	if (ret == 0 && sh7372_pd->resume && do_resume)	138	if (ret == 0 && sh7372_pd->resume && do_resume)
139	sh7372_pd->resume();	139	sh7372_pd->resume();
140		140
141	return ret;	141	return ret;
142	}	142	}
143		143
144	static int pd_power_up(struct generic_pm_domain *genpd)	144	static int pd_power_up(struct generic_pm_domain *genpd)
145	{	145	{
146	return __pd_power_up(to_sh7372_pd(genpd), true);	146	return __pd_power_up(to_sh7372_pd(genpd), true);
147	}	147	}
148		148
149	static int sh7372_a4r_suspend(void)	149	static int sh7372_a4r_suspend(void)
150	{	150	{
151	sh7372_intcs_suspend();	151	sh7372_intcs_suspend();
152	__raw_writel(0x300fffff, WUPRMSK); /* avoid wakeup */	152	__raw_writel(0x300fffff, WUPRMSK); /* avoid wakeup */
153	return 0;	153	return 0;
154	}	154	}
155		155
156	static bool pd_active_wakeup(struct device *dev)	156	static bool pd_active_wakeup(struct device *dev)
157	{	157	{
158	bool (active_wakeup)(struct device dev);	158	bool (active_wakeup)(struct device dev);
159		159
160	active_wakeup = dev_gpd_data(dev)->ops.active_wakeup;	160	active_wakeup = dev_gpd_data(dev)->ops.active_wakeup;
161	return active_wakeup ? active_wakeup(dev) : true;	161	return active_wakeup ? active_wakeup(dev) : true;
162	}	162	}
163		163
164	static int sh7372_stop_dev(struct device *dev)	164	static int sh7372_stop_dev(struct device *dev)
165	{	165	{
166	int (stop)(struct device dev);	166	int (stop)(struct device dev);
167		167
168	stop = dev_gpd_data(dev)->ops.stop;	168	stop = dev_gpd_data(dev)->ops.stop;
169	if (stop) {	169	if (stop) {
170	int ret = stop(dev);	170	int ret = stop(dev);
171	if (ret)	171	if (ret)
172	return ret;	172	return ret;
173	}	173	}
174	return pm_clk_suspend(dev);	174	return pm_clk_suspend(dev);
175	}	175	}
176		176
177	static int sh7372_start_dev(struct device *dev)	177	static int sh7372_start_dev(struct device *dev)
178	{	178	{
179	int (start)(struct device dev);	179	int (start)(struct device dev);
180	int ret;	180	int ret;
181		181
182	ret = pm_clk_resume(dev);	182	ret = pm_clk_resume(dev);
183	if (ret)	183	if (ret)
184	return ret;	184	return ret;
185		185
186	start = dev_gpd_data(dev)->ops.start;	186	start = dev_gpd_data(dev)->ops.start;
187	if (start)	187	if (start)
188	ret = start(dev);	188	ret = start(dev);
189		189
190	return ret;	190	return ret;
191	}	191	}
192		192
193	void sh7372_init_pm_domain(struct sh7372_pm_domain *sh7372_pd)	193	void sh7372_init_pm_domain(struct sh7372_pm_domain *sh7372_pd)
194	{	194	{
195	struct generic_pm_domain *genpd = &sh7372_pd->genpd;	195	struct generic_pm_domain *genpd = &sh7372_pd->genpd;
196	struct dev_power_governor *gov = sh7372_pd->gov;	196	struct dev_power_governor *gov = sh7372_pd->gov;
197		197
198	pm_genpd_init(genpd, gov ? : &simple_qos_governor, false);	198	pm_genpd_init(genpd, gov ? : &simple_qos_governor, false);
199	genpd->dev_ops.stop = sh7372_stop_dev;	199	genpd->dev_ops.stop = sh7372_stop_dev;
200	genpd->dev_ops.start = sh7372_start_dev;	200	genpd->dev_ops.start = sh7372_start_dev;
201	genpd->dev_ops.active_wakeup = pd_active_wakeup;	201	genpd->dev_ops.active_wakeup = pd_active_wakeup;
202	genpd->dev_irq_safe = true;	202	genpd->dev_irq_safe = true;
203	genpd->power_off = pd_power_down;	203	genpd->power_off = pd_power_down;
204	genpd->power_on = pd_power_up;	204	genpd->power_on = pd_power_up;
205	__pd_power_up(sh7372_pd, false);	205	__pd_power_up(sh7372_pd, false);
206	}	206	}
207		207
208	void sh7372_add_device_to_domain(struct sh7372_pm_domain *sh7372_pd,	208	void sh7372_add_device_to_domain(struct sh7372_pm_domain *sh7372_pd,
209	struct platform_device *pdev)	209	struct platform_device *pdev)
210	{	210	{
211	struct device *dev = &pdev->dev;	211	struct device *dev = &pdev->dev;
212		212
213	pm_genpd_add_device(&sh7372_pd->genpd, dev);	213	pm_genpd_add_device(&sh7372_pd->genpd, dev);
214	if (pm_clk_no_clocks(dev))	214	if (pm_clk_no_clocks(dev))
215	pm_clk_add(dev, NULL);	215	pm_clk_add(dev, NULL);
216	}	216	}
217		217
218	void sh7372_pm_add_subdomain(struct sh7372_pm_domain *sh7372_pd,	218	void sh7372_pm_add_subdomain(struct sh7372_pm_domain *sh7372_pd,
219	struct sh7372_pm_domain *sh7372_sd)	219	struct sh7372_pm_domain *sh7372_sd)
220	{	220	{
221	pm_genpd_add_subdomain(&sh7372_pd->genpd, &sh7372_sd->genpd);	221	pm_genpd_add_subdomain(&sh7372_pd->genpd, &sh7372_sd->genpd);
222	}	222	}
223		223
224	struct sh7372_pm_domain sh7372_a4lc = {	224	struct sh7372_pm_domain sh7372_a4lc = {
225	.genpd.name = "A4LC",	225	.genpd.name = "A4LC",
226	.bit_shift = 1,	226	.bit_shift = 1,
227	};	227	};
228		228
229	struct sh7372_pm_domain sh7372_a4mp = {	229	struct sh7372_pm_domain sh7372_a4mp = {
230	.genpd.name = "A4MP",	230	.genpd.name = "A4MP",
231	.bit_shift = 2,	231	.bit_shift = 2,
232	};	232	};
233		233
234	struct sh7372_pm_domain sh7372_d4 = {	234	struct sh7372_pm_domain sh7372_d4 = {
235	.genpd.name = "D4",	235	.genpd.name = "D4",
236	.bit_shift = 3,	236	.bit_shift = 3,
237	};	237	};
238		238
239	struct sh7372_pm_domain sh7372_a4r = {	239	struct sh7372_pm_domain sh7372_a4r = {
240	.genpd.name = "A4R",	240	.genpd.name = "A4R",
241	.bit_shift = 5,	241	.bit_shift = 5,
242	.suspend = sh7372_a4r_suspend,	242	.suspend = sh7372_a4r_suspend,
243	.resume = sh7372_intcs_resume,	243	.resume = sh7372_intcs_resume,
244	};	244	};
245		245
246	struct sh7372_pm_domain sh7372_a3rv = {	246	struct sh7372_pm_domain sh7372_a3rv = {
247	.genpd.name = "A3RV",	247	.genpd.name = "A3RV",
248	.bit_shift = 6,	248	.bit_shift = 6,
249	};	249	};
250		250
251	struct sh7372_pm_domain sh7372_a3ri = {	251	struct sh7372_pm_domain sh7372_a3ri = {
252	.genpd.name = "A3RI",	252	.genpd.name = "A3RI",
253	.bit_shift = 8,	253	.bit_shift = 8,
254	};	254	};
255		255
256	static int sh7372_a4s_suspend(void)	256	static int sh7372_a4s_suspend(void)
257	{	257	{
258	/*	258	/*
259	* The A4S domain contains the CPU core and therefore it should	259	* The A4S domain contains the CPU core and therefore it should
260	* only be turned off if the CPU is in use.	260	* only be turned off if the CPU is in use.
261	*/	261	*/
262	return -EBUSY;	262	return -EBUSY;
263	}	263	}
264		264
265	struct sh7372_pm_domain sh7372_a4s = {	265	struct sh7372_pm_domain sh7372_a4s = {
266	.genpd.name = "A4S",	266	.genpd.name = "A4S",
267	.bit_shift = 10,	267	.bit_shift = 10,
268	.gov = &pm_domain_always_on_gov,	268	.gov = &pm_domain_always_on_gov,
269	.no_debug = true,	269	.no_debug = true,
270	.suspend = sh7372_a4s_suspend,	270	.suspend = sh7372_a4s_suspend,
271	};	271	};
272		272
273	static int sh7372_a3sp_suspend(void)	273	static int sh7372_a3sp_suspend(void)
274	{	274	{
275	/*	275	/*
276	* Serial consoles make use of SCIF hardware located in A3SP,	276	* Serial consoles make use of SCIF hardware located in A3SP,
277	* keep such power domain on if "no_console_suspend" is set.	277	* keep such power domain on if "no_console_suspend" is set.
278	*/	278	*/
279	return console_suspend_enabled ? -EBUSY : 0;	279	return console_suspend_enabled ? 0 : -EBUSY;
280	}	280	}
281		281
282	struct sh7372_pm_domain sh7372_a3sp = {	282	struct sh7372_pm_domain sh7372_a3sp = {
283	.genpd.name = "A3SP",	283	.genpd.name = "A3SP",
284	.bit_shift = 11,	284	.bit_shift = 11,
285	.gov = &pm_domain_always_on_gov,	285	.gov = &pm_domain_always_on_gov,
286	.no_debug = true,	286	.no_debug = true,
287	.suspend = sh7372_a3sp_suspend,	287	.suspend = sh7372_a3sp_suspend,
288	};	288	};
289		289
290	struct sh7372_pm_domain sh7372_a3sg = {	290	struct sh7372_pm_domain sh7372_a3sg = {
291	.genpd.name = "A3SG",	291	.genpd.name = "A3SG",
292	.bit_shift = 13,	292	.bit_shift = 13,
293	};	293	};
294		294
295	#else /* !CONFIG_PM */	295	#else /* !CONFIG_PM */
296		296
297	static inline void sh7372_a3sp_init(void) {}	297	static inline void sh7372_a3sp_init(void) {}
298		298
299	#endif /* !CONFIG_PM */	299	#endif /* !CONFIG_PM */
300		300
301	#if defined(CONFIG_SUSPEND) \|\| defined(CONFIG_CPU_IDLE)	301	#if defined(CONFIG_SUSPEND) \|\| defined(CONFIG_CPU_IDLE)
302	static int sh7372_do_idle_core_standby(unsigned long unused)	302	static int sh7372_do_idle_core_standby(unsigned long unused)
303	{	303	{
304	cpu_do_idle(); /* WFI when SYSTBCR == 0x10 -> Core Standby */	304	cpu_do_idle(); /* WFI when SYSTBCR == 0x10 -> Core Standby */
305	return 0;	305	return 0;
306	}	306	}
307		307
308	static void sh7372_set_reset_vector(unsigned long address)	308	static void sh7372_set_reset_vector(unsigned long address)
309	{	309	{
310	/* set reset vector, translate 4k */	310	/* set reset vector, translate 4k */
311	__raw_writel(address, SBAR);	311	__raw_writel(address, SBAR);
312	__raw_writel(0, APARMBAREA);	312	__raw_writel(0, APARMBAREA);
313	}	313	}
314		314
315	static void sh7372_enter_core_standby(void)	315	static void sh7372_enter_core_standby(void)
316	{	316	{
317	sh7372_set_reset_vector(__pa(sh7372_resume_core_standby_sysc));	317	sh7372_set_reset_vector(__pa(sh7372_resume_core_standby_sysc));
318		318
319	/* enter sleep mode with SYSTBCR to 0x10 */	319	/* enter sleep mode with SYSTBCR to 0x10 */
320	__raw_writel(0x10, SYSTBCR);	320	__raw_writel(0x10, SYSTBCR);
321	cpu_suspend(0, sh7372_do_idle_core_standby);	321	cpu_suspend(0, sh7372_do_idle_core_standby);
322	__raw_writel(0, SYSTBCR);	322	__raw_writel(0, SYSTBCR);
323		323
324	/* disable reset vector translation */	324	/* disable reset vector translation */
325	__raw_writel(0, SBAR);	325	__raw_writel(0, SBAR);
326	}	326	}
327	#endif	327	#endif
328		328
329	#ifdef CONFIG_SUSPEND	329	#ifdef CONFIG_SUSPEND
330	static void sh7372_enter_sysc(int pllc0_on, unsigned long sleep_mode)	330	static void sh7372_enter_sysc(int pllc0_on, unsigned long sleep_mode)
331	{	331	{
332	if (pllc0_on)	332	if (pllc0_on)
333	__raw_writel(0, PLLC01STPCR);	333	__raw_writel(0, PLLC01STPCR);
334	else	334	else
335	__raw_writel(1 << 28, PLLC01STPCR);	335	__raw_writel(1 << 28, PLLC01STPCR);
336		336
337	__raw_readl(WUPSFAC); /* read wakeup int. factor before sleep */	337	__raw_readl(WUPSFAC); /* read wakeup int. factor before sleep */
338	cpu_suspend(sleep_mode, sh7372_do_idle_sysc);	338	cpu_suspend(sleep_mode, sh7372_do_idle_sysc);
339	__raw_readl(WUPSFAC); /* read wakeup int. factor after wakeup */	339	__raw_readl(WUPSFAC); /* read wakeup int. factor after wakeup */
340		340
341	/* disable reset vector translation */	341	/* disable reset vector translation */
342	__raw_writel(0, SBAR);	342	__raw_writel(0, SBAR);
343	}	343	}
344		344
345	static int sh7372_sysc_valid(unsigned long mskp, unsigned long msk2p)	345	static int sh7372_sysc_valid(unsigned long mskp, unsigned long msk2p)
346	{	346	{
347	unsigned long mstpsr0, mstpsr1, mstpsr2, mstpsr3, mstpsr4;	347	unsigned long mstpsr0, mstpsr1, mstpsr2, mstpsr3, mstpsr4;
348	unsigned long msk, msk2;	348	unsigned long msk, msk2;
349		349
350	/* check active clocks to determine potential wakeup sources */	350	/* check active clocks to determine potential wakeup sources */
351		351
352	mstpsr0 = __raw_readl(MSTPSR0);	352	mstpsr0 = __raw_readl(MSTPSR0);
353	if ((mstpsr0 & 0x00000003) != 0x00000003) {	353	if ((mstpsr0 & 0x00000003) != 0x00000003) {
354	pr_debug("sh7372 mstpsr0 0x%08lx\n", mstpsr0);	354	pr_debug("sh7372 mstpsr0 0x%08lx\n", mstpsr0);
355	return 0;	355	return 0;
356	}	356	}
357		357
358	mstpsr1 = __raw_readl(MSTPSR1);	358	mstpsr1 = __raw_readl(MSTPSR1);
359	if ((mstpsr1 & 0xff079b7f) != 0xff079b7f) {	359	if ((mstpsr1 & 0xff079b7f) != 0xff079b7f) {
360	pr_debug("sh7372 mstpsr1 0x%08lx\n", mstpsr1);	360	pr_debug("sh7372 mstpsr1 0x%08lx\n", mstpsr1);
361	return 0;	361	return 0;
362	}	362	}
363		363
364	mstpsr2 = __raw_readl(MSTPSR2);	364	mstpsr2 = __raw_readl(MSTPSR2);
365	if ((mstpsr2 & 0x000741ff) != 0x000741ff) {	365	if ((mstpsr2 & 0x000741ff) != 0x000741ff) {
366	pr_debug("sh7372 mstpsr2 0x%08lx\n", mstpsr2);	366	pr_debug("sh7372 mstpsr2 0x%08lx\n", mstpsr2);
367	return 0;	367	return 0;
368	}	368	}
369		369
370	mstpsr3 = __raw_readl(MSTPSR3);	370	mstpsr3 = __raw_readl(MSTPSR3);
371	if ((mstpsr3 & 0x1a60f010) != 0x1a60f010) {	371	if ((mstpsr3 & 0x1a60f010) != 0x1a60f010) {
372	pr_debug("sh7372 mstpsr3 0x%08lx\n", mstpsr3);	372	pr_debug("sh7372 mstpsr3 0x%08lx\n", mstpsr3);
373	return 0;	373	return 0;
374	}	374	}
375		375
376	mstpsr4 = __raw_readl(MSTPSR4);	376	mstpsr4 = __raw_readl(MSTPSR4);
377	if ((mstpsr4 & 0x00008cf0) != 0x00008cf0) {	377	if ((mstpsr4 & 0x00008cf0) != 0x00008cf0) {
378	pr_debug("sh7372 mstpsr4 0x%08lx\n", mstpsr4);	378	pr_debug("sh7372 mstpsr4 0x%08lx\n", mstpsr4);
379	return 0;	379	return 0;
380	}	380	}
381		381
382	msk = 0;	382	msk = 0;
383	msk2 = 0;	383	msk2 = 0;
384		384
385	/* make bitmaps of limited number of wakeup sources */	385	/* make bitmaps of limited number of wakeup sources */
386		386
387	if ((mstpsr2 & (1 << 23)) == 0) /* SPU2 */	387	if ((mstpsr2 & (1 << 23)) == 0) /* SPU2 */
388	msk \|= 1 << 31;	388	msk \|= 1 << 31;
389		389
390	if ((mstpsr2 & (1 << 12)) == 0) /* MFI_MFIM */	390	if ((mstpsr2 & (1 << 12)) == 0) /* MFI_MFIM */
391	msk \|= 1 << 21;	391	msk \|= 1 << 21;
392		392
393	if ((mstpsr4 & (1 << 3)) == 0) /* KEYSC */	393	if ((mstpsr4 & (1 << 3)) == 0) /* KEYSC */
394	msk \|= 1 << 2;	394	msk \|= 1 << 2;
395		395
396	if ((mstpsr1 & (1 << 24)) == 0) /* CMT0 */	396	if ((mstpsr1 & (1 << 24)) == 0) /* CMT0 */
397	msk \|= 1 << 1;	397	msk \|= 1 << 1;
398		398
399	if ((mstpsr3 & (1 << 29)) == 0) /* CMT1 */	399	if ((mstpsr3 & (1 << 29)) == 0) /* CMT1 */
400	msk \|= 1 << 1;	400	msk \|= 1 << 1;
401		401
402	if ((mstpsr4 & (1 << 0)) == 0) /* CMT2 */	402	if ((mstpsr4 & (1 << 0)) == 0) /* CMT2 */
403	msk \|= 1 << 1;	403	msk \|= 1 << 1;
404		404
405	if ((mstpsr2 & (1 << 13)) == 0) /* MFI_MFIS */	405	if ((mstpsr2 & (1 << 13)) == 0) /* MFI_MFIS */
406	msk2 \|= 1 << 17;	406	msk2 \|= 1 << 17;
407		407
408	*mskp = msk;	408	*mskp = msk;
409	*msk2p = msk2;	409	*msk2p = msk2;
410		410
411	return 1;	411	return 1;
412	}	412	}
413		413
414	static void sh7372_icr_to_irqcr(unsigned long icr, u16 irqcr1p, u16 irqcr2p)	414	static void sh7372_icr_to_irqcr(unsigned long icr, u16 irqcr1p, u16 irqcr2p)
415	{	415	{
416	u16 tmp, irqcr1, irqcr2;	416	u16 tmp, irqcr1, irqcr2;
417	int k;	417	int k;
418		418
419	irqcr1 = 0;	419	irqcr1 = 0;
420	irqcr2 = 0;	420	irqcr2 = 0;
421		421
422	/* convert INTCA ICR register layout to SYSC IRQCR+IRQCR2 */	422	/* convert INTCA ICR register layout to SYSC IRQCR+IRQCR2 */
423	for (k = 0; k <= 7; k++) {	423	for (k = 0; k <= 7; k++) {
424	tmp = (icr >> ((7 - k) * 4)) & 0xf;	424	tmp = (icr >> ((7 - k) * 4)) & 0xf;
425	irqcr1 \|= (tmp & 0x03) << (k * 2);	425	irqcr1 \|= (tmp & 0x03) << (k * 2);
426	irqcr2 \|= (tmp >> 2) << (k * 2);	426	irqcr2 \|= (tmp >> 2) << (k * 2);
427	}	427	}
428		428
429	*irqcr1p = irqcr1;	429	*irqcr1p = irqcr1;
430	*irqcr2p = irqcr2;	430	*irqcr2p = irqcr2;
431	}	431	}
432		432
433	static void sh7372_setup_sysc(unsigned long msk, unsigned long msk2)	433	static void sh7372_setup_sysc(unsigned long msk, unsigned long msk2)
434	{	434	{
435	u16 irqcrx_low, irqcrx_high, irqcry_low, irqcry_high;	435	u16 irqcrx_low, irqcrx_high, irqcry_low, irqcry_high;
436	unsigned long tmp;	436	unsigned long tmp;
437		437
438	/* read IRQ0A -> IRQ15A mask */	438	/* read IRQ0A -> IRQ15A mask */
439	tmp = bitrev8(__raw_readb(INTMSK00A));	439	tmp = bitrev8(__raw_readb(INTMSK00A));
440	tmp \|= bitrev8(__raw_readb(INTMSK10A)) << 8;	440	tmp \|= bitrev8(__raw_readb(INTMSK10A)) << 8;
441		441
442	/* setup WUPSMSK from clocks and external IRQ mask */	442	/* setup WUPSMSK from clocks and external IRQ mask */
443	msk = (~msk & 0xc030000f) \| (tmp << 4);	443	msk = (~msk & 0xc030000f) \| (tmp << 4);
444	__raw_writel(msk, WUPSMSK);	444	__raw_writel(msk, WUPSMSK);
445		445
446	/* propage level/edge trigger for external IRQ 0->15 */	446	/* propage level/edge trigger for external IRQ 0->15 */
447	sh7372_icr_to_irqcr(__raw_readl(ICR1A), &irqcrx_low, &irqcry_low);	447	sh7372_icr_to_irqcr(__raw_readl(ICR1A), &irqcrx_low, &irqcry_low);
448	sh7372_icr_to_irqcr(__raw_readl(ICR2A), &irqcrx_high, &irqcry_high);	448	sh7372_icr_to_irqcr(__raw_readl(ICR2A), &irqcrx_high, &irqcry_high);
449	__raw_writel((irqcrx_high << 16) \| irqcrx_low, IRQCR);	449	__raw_writel((irqcrx_high << 16) \| irqcrx_low, IRQCR);
450	__raw_writel((irqcry_high << 16) \| irqcry_low, IRQCR2);	450	__raw_writel((irqcry_high << 16) \| irqcry_low, IRQCR2);
451		451
452	/* read IRQ16A -> IRQ31A mask */	452	/* read IRQ16A -> IRQ31A mask */
453	tmp = bitrev8(__raw_readb(INTMSK20A));	453	tmp = bitrev8(__raw_readb(INTMSK20A));
454	tmp \|= bitrev8(__raw_readb(INTMSK30A)) << 8;	454	tmp \|= bitrev8(__raw_readb(INTMSK30A)) << 8;
455		455
456	/* setup WUPSMSK2 from clocks and external IRQ mask */	456	/* setup WUPSMSK2 from clocks and external IRQ mask */
457	msk2 = (~msk2 & 0x00030000) \| tmp;	457	msk2 = (~msk2 & 0x00030000) \| tmp;
458	__raw_writel(msk2, WUPSMSK2);	458	__raw_writel(msk2, WUPSMSK2);
459		459
460	/* propage level/edge trigger for external IRQ 16->31 */	460	/* propage level/edge trigger for external IRQ 16->31 */
461	sh7372_icr_to_irqcr(__raw_readl(ICR3A), &irqcrx_low, &irqcry_low);	461	sh7372_icr_to_irqcr(__raw_readl(ICR3A), &irqcrx_low, &irqcry_low);
462	sh7372_icr_to_irqcr(__raw_readl(ICR4A), &irqcrx_high, &irqcry_high);	462	sh7372_icr_to_irqcr(__raw_readl(ICR4A), &irqcrx_high, &irqcry_high);
463	__raw_writel((irqcrx_high << 16) \| irqcrx_low, IRQCR3);	463	__raw_writel((irqcrx_high << 16) \| irqcrx_low, IRQCR3);
464	__raw_writel((irqcry_high << 16) \| irqcry_low, IRQCR4);	464	__raw_writel((irqcry_high << 16) \| irqcry_low, IRQCR4);
465	}	465	}
466		466
467	static void sh7372_enter_a3sm_common(int pllc0_on)	467	static void sh7372_enter_a3sm_common(int pllc0_on)
468	{	468	{
469	sh7372_set_reset_vector(__pa(sh7372_resume_core_standby_sysc));	469	sh7372_set_reset_vector(__pa(sh7372_resume_core_standby_sysc));
470	sh7372_enter_sysc(pllc0_on, 1 << 12);	470	sh7372_enter_sysc(pllc0_on, 1 << 12);
471	}	471	}
472		472
473	static void sh7372_enter_a4s_common(int pllc0_on)	473	static void sh7372_enter_a4s_common(int pllc0_on)
474	{	474	{
475	sh7372_intca_suspend();	475	sh7372_intca_suspend();
476	memcpy((void *)SMFRAM, sh7372_resume_core_standby_sysc, 0x100);	476	memcpy((void *)SMFRAM, sh7372_resume_core_standby_sysc, 0x100);
477	sh7372_set_reset_vector(SMFRAM);	477	sh7372_set_reset_vector(SMFRAM);
478	sh7372_enter_sysc(pllc0_on, 1 << 10);	478	sh7372_enter_sysc(pllc0_on, 1 << 10);
479	sh7372_intca_resume();	479	sh7372_intca_resume();
480	}	480	}
481		481
482	#endif	482	#endif
483		483
484	#ifdef CONFIG_CPU_IDLE	484	#ifdef CONFIG_CPU_IDLE
485		485
486	static void sh7372_cpuidle_setup(struct cpuidle_driver *drv)	486	static void sh7372_cpuidle_setup(struct cpuidle_driver *drv)
487	{	487	{
488	struct cpuidle_state *state = &drv->states[drv->state_count];	488	struct cpuidle_state *state = &drv->states[drv->state_count];
489		489
490	snprintf(state->name, CPUIDLE_NAME_LEN, "C2");	490	snprintf(state->name, CPUIDLE_NAME_LEN, "C2");
491	strncpy(state->desc, "Core Standby Mode", CPUIDLE_DESC_LEN);	491	strncpy(state->desc, "Core Standby Mode", CPUIDLE_DESC_LEN);
492	state->exit_latency = 10;	492	state->exit_latency = 10;
493	state->target_residency = 20 + 10;	493	state->target_residency = 20 + 10;
494	state->flags = CPUIDLE_FLAG_TIME_VALID;	494	state->flags = CPUIDLE_FLAG_TIME_VALID;
495	shmobile_cpuidle_modes[drv->state_count] = sh7372_enter_core_standby;	495	shmobile_cpuidle_modes[drv->state_count] = sh7372_enter_core_standby;
496		496
497	drv->state_count++;	497	drv->state_count++;
498	}	498	}
499		499
500	static void sh7372_cpuidle_init(void)	500	static void sh7372_cpuidle_init(void)
501	{	501	{
502	shmobile_cpuidle_setup = sh7372_cpuidle_setup;	502	shmobile_cpuidle_setup = sh7372_cpuidle_setup;
503	}	503	}
504	#else	504	#else
505	static void sh7372_cpuidle_init(void) {}	505	static void sh7372_cpuidle_init(void) {}
506	#endif	506	#endif
507		507
508	#ifdef CONFIG_SUSPEND	508	#ifdef CONFIG_SUSPEND
509		509
510	static int sh7372_enter_suspend(suspend_state_t suspend_state)	510	static int sh7372_enter_suspend(suspend_state_t suspend_state)
511	{	511	{
512	unsigned long msk, msk2;	512	unsigned long msk, msk2;
513		513
514	/* check active clocks to determine potential wakeup sources */	514	/* check active clocks to determine potential wakeup sources */
515	if (sh7372_sysc_valid(&msk, &msk2)) {	515	if (sh7372_sysc_valid(&msk, &msk2)) {
516	/* convert INTC mask and sense to SYSC mask and sense */	516	/* convert INTC mask and sense to SYSC mask and sense */
517	sh7372_setup_sysc(msk, msk2);	517	sh7372_setup_sysc(msk, msk2);
518		518
519	if (!console_suspend_enabled &&	519	if (!console_suspend_enabled &&
520	sh7372_a4s.genpd.status == GPD_STATE_POWER_OFF) {	520	sh7372_a4s.genpd.status == GPD_STATE_POWER_OFF) {
521	/* enter A4S sleep with PLLC0 off */	521	/* enter A4S sleep with PLLC0 off */
522	pr_debug("entering A4S\n");	522	pr_debug("entering A4S\n");
523	sh7372_enter_a4s_common(0);	523	sh7372_enter_a4s_common(0);
524	} else {	524	} else {
525	/* enter A3SM sleep with PLLC0 off */	525	/* enter A3SM sleep with PLLC0 off */
526	pr_debug("entering A3SM\n");	526	pr_debug("entering A3SM\n");
527	sh7372_enter_a3sm_common(0);	527	sh7372_enter_a3sm_common(0);
528	}	528	}
529	} else {	529	} else {
530	/* default to Core Standby that supports all wakeup sources */	530	/* default to Core Standby that supports all wakeup sources */
531	pr_debug("entering Core Standby\n");	531	pr_debug("entering Core Standby\n");
532	sh7372_enter_core_standby();	532	sh7372_enter_core_standby();
533	}	533	}
534	return 0;	534	return 0;
535	}	535	}
536		536
537	/**	537	/**
538	* sh7372_pm_notifier_fn - SH7372 PM notifier routine.	538	* sh7372_pm_notifier_fn - SH7372 PM notifier routine.
539	* @notifier: Unused.	539	* @notifier: Unused.
540	* @pm_event: Event being handled.	540	* @pm_event: Event being handled.
541	* @unused: Unused.	541	* @unused: Unused.
542	*/	542	*/
543	static int sh7372_pm_notifier_fn(struct notifier_block *notifier,	543	static int sh7372_pm_notifier_fn(struct notifier_block *notifier,
544	unsigned long pm_event, void *unused)	544	unsigned long pm_event, void *unused)
545	{	545	{
546	switch (pm_event) {	546	switch (pm_event) {
547	case PM_SUSPEND_PREPARE:	547	case PM_SUSPEND_PREPARE:
548	/*	548	/*
549	* This is necessary, because the A4R domain has to be "on"	549	* This is necessary, because the A4R domain has to be "on"
550	* when suspend_device_irqs() and resume_device_irqs() are	550	* when suspend_device_irqs() and resume_device_irqs() are
551	* executed during system suspend and resume, respectively, so	551	* executed during system suspend and resume, respectively, so
552	* that those functions don't crash while accessing the INTCS.	552	* that those functions don't crash while accessing the INTCS.
553	*/	553	*/
554	pm_genpd_poweron(&sh7372_a4r.genpd);	554	pm_genpd_poweron(&sh7372_a4r.genpd);
555	break;	555	break;
556	case PM_POST_SUSPEND:	556	case PM_POST_SUSPEND:
557	pm_genpd_poweroff_unused();	557	pm_genpd_poweroff_unused();
558	break;	558	break;
559	}	559	}
560		560
561	return NOTIFY_DONE;	561	return NOTIFY_DONE;
562	}	562	}
563		563
564	static void sh7372_suspend_init(void)	564	static void sh7372_suspend_init(void)
565	{	565	{
566	shmobile_suspend_ops.enter = sh7372_enter_suspend;	566	shmobile_suspend_ops.enter = sh7372_enter_suspend;
567	pm_notifier(sh7372_pm_notifier_fn, 0);	567	pm_notifier(sh7372_pm_notifier_fn, 0);
568	}	568	}
569	#else	569	#else
570	static void sh7372_suspend_init(void) {}	570	static void sh7372_suspend_init(void) {}
571	#endif	571	#endif
572		572
573	void __init sh7372_pm_init(void)	573	void __init sh7372_pm_init(void)
574	{	574	{
575	/* enable DBG hardware block to kick SYSC */	575	/* enable DBG hardware block to kick SYSC */
576	__raw_writel(0x0000a500, DBGREG9);	576	__raw_writel(0x0000a500, DBGREG9);
577	__raw_writel(0x0000a501, DBGREG9);	577	__raw_writel(0x0000a501, DBGREG9);
578	__raw_writel(0x00000000, DBGREG1);	578	__raw_writel(0x00000000, DBGREG1);
579		579
580	/* do not convert A3SM, A3SP, A3SG, A4R power down into A4S */	580	/* do not convert A3SM, A3SP, A3SG, A4R power down into A4S */
581	__raw_writel(0, PDNSEL);	581	__raw_writel(0, PDNSEL);
582		582
583	sh7372_suspend_init();	583	sh7372_suspend_init();
584	sh7372_cpuidle_init();	584	sh7372_cpuidle_init();
585	}	585	}
586		586

drivers/base/power/domain.c

Diff comments View file @ 9774040

 /*
  * drivers/base/power/domain.c - Common code related to device power domains.
  *
  * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
  *
  * This file is released under the GPLv2.
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/io.h>
 #include <linux/pm_runtime.h>
 #include <linux/pm_domain.h>
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/sched.h>
 #include <linux/suspend.h>
 #include <linux/export.h>
 #define GENPD_DEV_CALLBACK(genpd, type, callback, dev)		\
 ({								\
 	type (*__routine)(struct device *__d); 			\
 	type __ret = (type)0;					\
 								\
 	__routine = genpd->dev_ops.callback; 			\
 	if (__routine) {					\
 		__ret = __routine(dev); 			\
 	} else {						\
 		__routine = dev_gpd_data(dev)->ops.callback;	\
 		if (__routine) 					\
 			__ret = __routine(dev);			\
 	}							\
 	__ret;							\
 })
 #define GENPD_DEV_TIMED_CALLBACK(genpd, type, callback, dev, field, name)	\
 ({										\
 	ktime_t __start = ktime_get();						\
 	type __retval = GENPD_DEV_CALLBACK(genpd, type, callback, dev);		\
 	s64 __elapsed = ktime_to_ns(ktime_sub(ktime_get(), __start));		\
 	struct generic_pm_domain_data *__gpd_data = dev_gpd_data(dev);		\
 	if (__elapsed > __gpd_data->td.field) {					\
 		__gpd_data->td.field = __elapsed;				\
 		dev_warn(dev, name " latency exceeded, new value %lld ns\n",	\
 			__elapsed);						\
 	}									\
 	__retval;								\
 })
 static LIST_HEAD(gpd_list);
 static DEFINE_MUTEX(gpd_list_lock);
 #ifdef CONFIG_PM
 struct generic_pm_domain *dev_to_genpd(struct device *dev)
 {
 	if (IS_ERR_OR_NULL(dev->pm_domain))
 		return ERR_PTR(-EINVAL);
 	return pd_to_genpd(dev->pm_domain);
 }
 static int genpd_stop_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, stop, dev,
 					stop_latency_ns, "stop");
 }
 static int genpd_start_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, start, dev,
 					start_latency_ns, "start");
 }
 static int genpd_save_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, save_state, dev,
 					save_state_latency_ns, "state save");
 }
 static int genpd_restore_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_TIMED_CALLBACK(genpd, int, restore_state, dev,
 					restore_state_latency_ns,
 					"state restore");
 }
 static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
 {
 	bool ret = false;
 	if (!WARN_ON(atomic_read(&genpd->sd_count) == 0))
 		ret = !!atomic_dec_and_test(&genpd->sd_count);
 	return ret;
 }
 static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
 {
 	atomic_inc(&genpd->sd_count);
 	smp_mb__after_atomic_inc();
 }
 static void genpd_acquire_lock(struct generic_pm_domain *genpd)
 {
 	DEFINE_WAIT(wait);
 	mutex_lock(&genpd->lock);
 	/*
 	 * Wait for the domain to transition into either the active,
 	 * or the power off state.
 	 */
 	for (;;) {
 		prepare_to_wait(&genpd->status_wait_queue, &wait,
 				TASK_UNINTERRUPTIBLE);
 		if (genpd->status == GPD_STATE_ACTIVE
 		    || genpd->status == GPD_STATE_POWER_OFF)
 			break;
 		mutex_unlock(&genpd->lock);
 		schedule();
 		mutex_lock(&genpd->lock);
 	}
 	finish_wait(&genpd->status_wait_queue, &wait);
 }
 static void genpd_release_lock(struct generic_pm_domain *genpd)
 {
 	mutex_unlock(&genpd->lock);
 }
 static void genpd_set_active(struct generic_pm_domain *genpd)
 {
 	if (genpd->resume_count == 0)
 		genpd->status = GPD_STATE_ACTIVE;
 }
 /**
  * __pm_genpd_poweron - Restore power to a given PM domain and its masters.
  * @genpd: PM domain to power up.
  *
  * Restore power to @genpd and all of its masters so that it is possible to
  * resume a device belonging to it.
  */
 int __pm_genpd_poweron(struct generic_pm_domain *genpd)
 	__releases(&genpd->lock) __acquires(&genpd->lock)
 {
 	struct gpd_link *link;
 	DEFINE_WAIT(wait);
 	int ret = 0;
 	/* If the domain's master is being waited for, we have to wait too. */
 	for (;;) {
 		prepare_to_wait(&genpd->status_wait_queue, &wait,
 				TASK_UNINTERRUPTIBLE);
 		if (genpd->status != GPD_STATE_WAIT_MASTER)
 			break;
 		mutex_unlock(&genpd->lock);
 		schedule();
 		mutex_lock(&genpd->lock);
 	}
 	finish_wait(&genpd->status_wait_queue, &wait);
 	if (genpd->status == GPD_STATE_ACTIVE
 	    || (genpd->prepared_count > 0 && genpd->suspend_power_off))
 		return 0;
 	if (genpd->status != GPD_STATE_POWER_OFF) {
 		genpd_set_active(genpd);
 		return 0;
 	}
 	/*
 	 * The list is guaranteed not to change while the loop below is being
 	 * executed, unless one of the masters' .power_on() callbacks fiddles
 	 * with it.
 	 */
 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
 		genpd_sd_counter_inc(link->master);
 		genpd->status = GPD_STATE_WAIT_MASTER;
 		mutex_unlock(&genpd->lock);
 		ret = pm_genpd_poweron(link->master);
 		mutex_lock(&genpd->lock);
 		/*
 		 * The "wait for parent" status is guaranteed not to change
 		 * while the master is powering on.
 		 */
 		genpd->status = GPD_STATE_POWER_OFF;
 		wake_up_all(&genpd->status_wait_queue);
 		if (ret) {
 			genpd_sd_counter_dec(link->master);
 			goto err;
 		}
 	}
 	if (genpd->power_on) {
 		ktime_t time_start = ktime_get();
 		s64 elapsed_ns;
 		ret = genpd->power_on(genpd);
 		if (ret)
 			goto err;
 		elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 		if (elapsed_ns > genpd->power_on_latency_ns) {
 			genpd->power_on_latency_ns = elapsed_ns;
 			if (genpd->name)
 				pr_warning("%s: Power-on latency exceeded, "
 					"new value %lld ns\n", genpd->name,
 					elapsed_ns);
 		}
 	}
 	genpd_set_active(genpd);
 	return 0;
  err:
 	list_for_each_entry_continue_reverse(link, &genpd->slave_links, slave_node)
 		genpd_sd_counter_dec(link->master);
 	return ret;
 }
 /**
  * pm_genpd_poweron - Restore power to a given PM domain and its masters.
  * @genpd: PM domain to power up.
  */
 int pm_genpd_poweron(struct generic_pm_domain *genpd)
 {
 	int ret;
 	mutex_lock(&genpd->lock);
 	ret = __pm_genpd_poweron(genpd);
 	mutex_unlock(&genpd->lock);
 	return ret;
 }
 #endif /* CONFIG_PM */
 #ifdef CONFIG_PM_RUNTIME
 /**
  * __pm_genpd_save_device - Save the pre-suspend state of a device.
  * @pdd: Domain data of the device to save the state of.
  * @genpd: PM domain the device belongs to.
  */
 static int __pm_genpd_save_device(struct pm_domain_data *pdd,
 				  struct generic_pm_domain *genpd)
 	__releases(&genpd->lock) __acquires(&genpd->lock)
 {
 	struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
 	struct device *dev = pdd->dev;
 	int ret = 0;
 	if (gpd_data->need_restore)
 		return 0;
 	mutex_unlock(&genpd->lock);
 	genpd_start_dev(genpd, dev);
 	ret = genpd_save_dev(genpd, dev);
 	genpd_stop_dev(genpd, dev);
 	mutex_lock(&genpd->lock);
 	if (!ret)
 		gpd_data->need_restore = true;
 	return ret;
 }
 /**
  * __pm_genpd_restore_device - Restore the pre-suspend state of a device.
  * @pdd: Domain data of the device to restore the state of.
  * @genpd: PM domain the device belongs to.
  */
 static void __pm_genpd_restore_device(struct pm_domain_data *pdd,
 				      struct generic_pm_domain *genpd)
 	__releases(&genpd->lock) __acquires(&genpd->lock)
 {
 	struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
 	struct device *dev = pdd->dev;
 	if (!gpd_data->need_restore)
 		return;
 	mutex_unlock(&genpd->lock);
 	genpd_start_dev(genpd, dev);
 	genpd_restore_dev(genpd, dev);
 	genpd_stop_dev(genpd, dev);
 	mutex_lock(&genpd->lock);
 	gpd_data->need_restore = false;
 }
 /**
  * genpd_abort_poweroff - Check if a PM domain power off should be aborted.
  * @genpd: PM domain to check.
  *
  * Return true if a PM domain's status changed to GPD_STATE_ACTIVE during
  * a "power off" operation, which means that a "power on" has occured in the
  * meantime, or if its resume_count field is different from zero, which means
  * that one of its devices has been resumed in the meantime.
  */
 static bool genpd_abort_poweroff(struct generic_pm_domain *genpd)
 {
 	return genpd->status == GPD_STATE_WAIT_MASTER
 		|| genpd->status == GPD_STATE_ACTIVE || genpd->resume_count > 0;
 }
 /**
  * genpd_queue_power_off_work - Queue up the execution of pm_genpd_poweroff().
  * @genpd: PM domait to power off.
  *
  * Queue up the execution of pm_genpd_poweroff() unless it's already been done
  * before.
  */
 void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
 {
 	if (!work_pending(&genpd->power_off_work))
 		queue_work(pm_wq, &genpd->power_off_work);
 }
 /**
  * pm_genpd_poweroff - Remove power from a given PM domain.
  * @genpd: PM domain to power down.
  *
  * If all of the @genpd's devices have been suspended and all of its subdomains
  * have been powered down, run the runtime suspend callbacks provided by all of
  * the @genpd's devices' drivers and remove power from @genpd.
  */
 static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
 	__releases(&genpd->lock) __acquires(&genpd->lock)
 {
 	struct pm_domain_data *pdd;
 	struct gpd_link *link;
 	unsigned int not_suspended;
 	int ret = 0;
  start:
 	/*
 	 * Do not try to power off the domain in the following situations:
 	 * (1) The domain is already in the "power off" state.
 	 * (2) The domain is waiting for its master to power up.
 	 * (3) One of the domain's devices is being resumed right now.
 	 * (4) System suspend is in progress.
 	 */
 	if (genpd->status == GPD_STATE_POWER_OFF
 	    || genpd->status == GPD_STATE_WAIT_MASTER
 	    || genpd->resume_count > 0 || genpd->prepared_count > 0)
 		return 0;
 	if (atomic_read(&genpd->sd_count) > 0)
 		return -EBUSY;
 	not_suspended = 0;
 	list_for_each_entry(pdd, &genpd->dev_list, list_node)
 		if (pdd->dev->driver && (!pm_runtime_suspended(pdd->dev)
 		    || pdd->dev->power.irq_safe))
 			not_suspended++;
 	if (not_suspended > genpd->in_progress)
 		return -EBUSY;
 	if (genpd->poweroff_task) {
 		/*
 		 * Another instance of pm_genpd_poweroff() is executing
 		 * callbacks, so tell it to start over and return.
 		 */
 		genpd->status = GPD_STATE_REPEAT;
 		return 0;
 	}
 	if (genpd->gov && genpd->gov->power_down_ok) {
 		if (!genpd->gov->power_down_ok(&genpd->domain))
 			return -EAGAIN;
 	}
 	genpd->status = GPD_STATE_BUSY;
 	genpd->poweroff_task = current;
 	list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
 		ret = atomic_read(&genpd->sd_count) == 0 ?
 			__pm_genpd_save_device(pdd, genpd) : -EBUSY;
 		if (genpd_abort_poweroff(genpd))
 			goto out;
 		if (ret) {
 			genpd_set_active(genpd);
 			goto out;
 		}
 		if (genpd->status == GPD_STATE_REPEAT) {
 			genpd->poweroff_task = NULL;
 			goto start;
 		}
 	}
 	if (genpd->power_off) {
 		ktime_t time_start;
 		s64 elapsed_ns;
 		if (atomic_read(&genpd->sd_count) > 0) {
 			ret = -EBUSY;
 			goto out;
 		}
 		time_start = ktime_get();
 		/*
 		 * If sd_count > 0 at this point, one of the subdomains hasn't
 		 * managed to call pm_genpd_poweron() for the master yet after
 		 * incrementing it.  In that case pm_genpd_poweron() will wait
 		 * for us to drop the lock, so we can call .power_off() and let
 		 * the pm_genpd_poweron() restore power for us (this shouldn't
 		 * happen very often).
 		 */
 		ret = genpd->power_off(genpd);
 		if (ret == -EBUSY) {
 			genpd_set_active(genpd);
 			goto out;
 		}
 		elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
 		if (elapsed_ns > genpd->power_off_latency_ns) {
 			genpd->power_off_latency_ns = elapsed_ns;
 			if (genpd->name)
 				pr_warning("%s: Power-off latency exceeded, "
 					"new value %lld ns\n", genpd->name,
 					elapsed_ns);
 		}
 	}
 	genpd->status = GPD_STATE_POWER_OFF;
 	genpd->power_off_time = ktime_get();
 	/* Update PM QoS information for devices in the domain. */
 	list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
 		struct gpd_timing_data *td = &to_gpd_data(pdd)->td;
 		pm_runtime_update_max_time_suspended(pdd->dev,
 					td->start_latency_ns +
 					td->restore_state_latency_ns +
 					genpd->power_on_latency_ns);
 	}
 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
 		genpd_sd_counter_dec(link->master);
 		genpd_queue_power_off_work(link->master);
 	}
  out:
 	genpd->poweroff_task = NULL;
 	wake_up_all(&genpd->status_wait_queue);
 	return ret;
 }
 /**
  * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0.
  * @work: Work structure used for scheduling the execution of this function.
  */
 static void genpd_power_off_work_fn(struct work_struct *work)
 {
 	struct generic_pm_domain *genpd;
 	genpd = container_of(work, struct generic_pm_domain, power_off_work);
 	genpd_acquire_lock(genpd);
 	pm_genpd_poweroff(genpd);
 	genpd_release_lock(genpd);
 }
 /**
  * pm_genpd_runtime_suspend - Suspend a device belonging to I/O PM domain.
  * @dev: Device to suspend.
  *
  * Carry out a runtime suspend of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
  */
 static int pm_genpd_runtime_suspend(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	bool (*stop_ok)(struct device *__dev);
 	int ret;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	might_sleep_if(!genpd->dev_irq_safe);
 	stop_ok = genpd->gov ? genpd->gov->stop_ok : NULL;
 	if (stop_ok && !stop_ok(dev))
 		return -EBUSY;
 	ret = genpd_stop_dev(genpd, dev);
 	if (ret)
 		return ret;
 	pm_runtime_update_max_time_suspended(dev,
 				dev_gpd_data(dev)->td.start_latency_ns);
 	/*
 	 * If power.irq_safe is set, this routine will be run with interrupts
 	 * off, so it can't use mutexes.
 	 */
 	if (dev->power.irq_safe)
 		return 0;
 	mutex_lock(&genpd->lock);
 	genpd->in_progress++;
 	pm_genpd_poweroff(genpd);
 	genpd->in_progress--;
 	mutex_unlock(&genpd->lock);
 	return 0;
 }
 /**
  * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
  * @dev: Device to resume.
  *
  * Carry out a runtime resume of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
  */
 static int pm_genpd_runtime_resume(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	DEFINE_WAIT(wait);
 	int ret;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	might_sleep_if(!genpd->dev_irq_safe);
 	/* If power.irq_safe, the PM domain is never powered off. */
 	if (dev->power.irq_safe)
 		goto out;
 	mutex_lock(&genpd->lock);
 	ret = __pm_genpd_poweron(genpd);
 	if (ret) {
 		mutex_unlock(&genpd->lock);
 		return ret;
 	}
 	genpd->status = GPD_STATE_BUSY;
 	genpd->resume_count++;
 	for (;;) {
 		prepare_to_wait(&genpd->status_wait_queue, &wait,
 				TASK_UNINTERRUPTIBLE);
 		/*
 		 * If current is the powering off task, we have been called
 		 * reentrantly from one of the device callbacks, so we should
 		 * not wait.
 		 */
 		if (!genpd->poweroff_task || genpd->poweroff_task == current)
 			break;
 		mutex_unlock(&genpd->lock);
 		schedule();
 		mutex_lock(&genpd->lock);
 	}
 	finish_wait(&genpd->status_wait_queue, &wait);
 	__pm_genpd_restore_device(dev->power.subsys_data->domain_data, genpd);
 	genpd->resume_count--;
 	genpd_set_active(genpd);
 	wake_up_all(&genpd->status_wait_queue);
 	mutex_unlock(&genpd->lock);
  out:
 	genpd_start_dev(genpd, dev);
 	return 0;
 }
 /**
  * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
  */
 void pm_genpd_poweroff_unused(void)
 {
 	struct generic_pm_domain *genpd;
 	mutex_lock(&gpd_list_lock);
 	list_for_each_entry(genpd, &gpd_list, gpd_list_node)
 		genpd_queue_power_off_work(genpd);
 	mutex_unlock(&gpd_list_lock);
 }
 #else
 static inline void genpd_power_off_work_fn(struct work_struct *work) {}
 #define pm_genpd_runtime_suspend	NULL
 #define pm_genpd_runtime_resume		NULL
 #endif /* CONFIG_PM_RUNTIME */
 #ifdef CONFIG_PM_SLEEP
 static bool genpd_dev_active_wakeup(struct generic_pm_domain *genpd,
 				    struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, bool, active_wakeup, dev);
 }
 static int genpd_suspend_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, suspend, dev);
 }
 static int genpd_suspend_late(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, suspend_late, dev);
 }
 static int genpd_resume_early(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, resume_early, dev);
 }
 static int genpd_resume_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, resume, dev);
 }
 static int genpd_freeze_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, freeze, dev);
 }
 static int genpd_freeze_late(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, freeze_late, dev);
 }
 static int genpd_thaw_early(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, thaw_early, dev);
 }
 static int genpd_thaw_dev(struct generic_pm_domain *genpd, struct device *dev)
 {
 	return GENPD_DEV_CALLBACK(genpd, int, thaw, dev);
 }
 /**
  * pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
  * @genpd: PM domain to power off, if possible.
  *
  * Check if the given PM domain can be powered off (during system suspend or
  * hibernation) and do that if so.  Also, in that case propagate to its masters.
  *
  * This function is only called in "noirq" stages of system power transitions,
  * so it need not acquire locks (all of the "noirq" callbacks are executed
  * sequentially, so it is guaranteed that it will never run twice in parallel).
  */
 static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
 {
 	struct gpd_link *link;
 	if (genpd->status == GPD_STATE_POWER_OFF)
 		return;
 	if (genpd->suspended_count != genpd->device_count
 	    || atomic_read(&genpd->sd_count) > 0)
 		return;
 	if (genpd->power_off)
 		genpd->power_off(genpd);
 	genpd->status = GPD_STATE_POWER_OFF;
 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
 		genpd_sd_counter_dec(link->master);
 		pm_genpd_sync_poweroff(link->master);
 	}
 }
 /**
  * resume_needed - Check whether to resume a device before system suspend.
  * @dev: Device to check.
  * @genpd: PM domain the device belongs to.
  *
  * There are two cases in which a device that can wake up the system from sleep
  * states should be resumed by pm_genpd_prepare(): (1) if the device is enabled
  * to wake up the system and it has to remain active for this purpose while the
  * system is in the sleep state and (2) if the device is not enabled to wake up
  * the system from sleep states and it generally doesn't generate wakeup signals
  * by itself (those signals are generated on its behalf by other parts of the
  * system).  In the latter case it may be necessary to reconfigure the device's
  * wakeup settings during system suspend, because it may have been set up to
  * signal remote wakeup from the system's working state as needed by runtime PM.
  * Return 'true' in either of the above cases.
  */
 static bool resume_needed(struct device *dev, struct generic_pm_domain *genpd)
 {
 	bool active_wakeup;
 	if (!device_can_wakeup(dev))
 		return false;
 	active_wakeup = genpd_dev_active_wakeup(genpd, dev);
 	return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
 }
 /**
  * pm_genpd_prepare - Start power transition of a device in a PM domain.
  * @dev: Device to start the transition of.
  *
  * Start a power transition of a device (during a system-wide power transition)
  * under the assumption that its pm_domain field points to the domain member of
  * an object of type struct generic_pm_domain representing a PM domain
  * consisting of I/O devices.
  */
 static int pm_genpd_prepare(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	int ret;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	/*
 	 * If a wakeup request is pending for the device, it should be woken up
 	 * at this point and a system wakeup event should be reported if it's
 	 * set up to wake up the system from sleep states.
 	 */
 	pm_runtime_get_noresume(dev);
 	if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
 		pm_wakeup_event(dev, 0);
 	if (pm_wakeup_pending()) {
 		pm_runtime_put_sync(dev);
 		return -EBUSY;
 	}
 	if (resume_needed(dev, genpd))
 		pm_runtime_resume(dev);
 	genpd_acquire_lock(genpd);
 	if (genpd->prepared_count++ == 0)
 		genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
 	genpd_release_lock(genpd);
 	if (genpd->suspend_power_off) {
 		pm_runtime_put_noidle(dev);
 		return 0;
 	}
 	/*
 	 * The PM domain must be in the GPD_STATE_ACTIVE state at this point,
 	 * so pm_genpd_poweron() will return immediately, but if the device
 	 * is suspended (e.g. it's been stopped by genpd_stop_dev()), we need
 	 * to make it operational.
 	 */
 	pm_runtime_resume(dev);
 	__pm_runtime_disable(dev, false);
 	ret = pm_generic_prepare(dev);
 	if (ret) {
 		mutex_lock(&genpd->lock);
 		if (--genpd->prepared_count == 0)
 			genpd->suspend_power_off = false;
 		mutex_unlock(&genpd->lock);
 		pm_runtime_enable(dev);
 	}
 	pm_runtime_put_sync(dev);
 	return ret;
 }
 /**
  * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
  * @dev: Device to suspend.
  *
  * Suspend a device under the assumption that its pm_domain field points to the
  * domain member of an object of type struct generic_pm_domain representing
  * a PM domain consisting of I/O devices.
  */
 static int pm_genpd_suspend(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	return genpd->suspend_power_off ? 0 : genpd_suspend_dev(genpd, dev);
 }
 /**
  * pm_genpd_suspend_noirq - Late suspend of a device from an I/O PM domain.
  * @dev: Device to suspend.
  *
  * Carry out a late suspend of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a PM domain consisting of I/O devices.
  */
 static int pm_genpd_suspend_noirq(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	int ret;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	if (genpd->suspend_power_off)
 		return 0;
 	ret = genpd_suspend_late(genpd, dev);
 	if (ret)
 		return ret;
 	if (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev))
 		return 0;
 	genpd_stop_dev(genpd, dev);
 	/*
 	 * Since all of the "noirq" callbacks are executed sequentially, it is
 	 * guaranteed that this function will never run twice in parallel for
 	 * the same PM domain, so it is not necessary to use locking here.
 	 */
 	genpd->suspended_count++;
 	pm_genpd_sync_poweroff(genpd);
 	return 0;
 }
 /**
  * pm_genpd_resume_noirq - Early resume of a device from an I/O power domain.
  * @dev: Device to resume.
  *
  * Carry out an early resume of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a power domain consisting of I/O
  * devices.
  */
 static int pm_genpd_resume_noirq(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	if (genpd->suspend_power_off)
 		return 0;
 	/*
 	 * Since all of the "noirq" callbacks are executed sequentially, it is
 	 * guaranteed that this function will never run twice in parallel for
 	 * the same PM domain, so it is not necessary to use locking here.
 	 */
 	pm_genpd_poweron(genpd);
 	genpd->suspended_count--;
 	genpd_start_dev(genpd, dev);
 	return genpd_resume_early(genpd, dev);
 }
 /**
  * pm_genpd_resume - Resume a device belonging to an I/O power domain.
  * @dev: Device to resume.
  *
  * Resume a device under the assumption that its pm_domain field points to the
  * domain member of an object of type struct generic_pm_domain representing
  * a power domain consisting of I/O devices.
  */
 static int pm_genpd_resume(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	return genpd->suspend_power_off ? 0 : genpd_resume_dev(genpd, dev);
 }
 /**
  * pm_genpd_freeze - Freeze a device belonging to an I/O power domain.
  * @dev: Device to freeze.
  *
  * Freeze a device under the assumption that its pm_domain field points to the
  * domain member of an object of type struct generic_pm_domain representing
  * a power domain consisting of I/O devices.
  */
 static int pm_genpd_freeze(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	return genpd->suspend_power_off ? 0 : genpd_freeze_dev(genpd, dev);
 }
 /**
  * pm_genpd_freeze_noirq - Late freeze of a device from an I/O power domain.
  * @dev: Device to freeze.
  *
  * Carry out a late freeze of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a power domain consisting of I/O
  * devices.
  */
 static int pm_genpd_freeze_noirq(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	int ret;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	if (genpd->suspend_power_off)
 		return 0;
 	ret = genpd_freeze_late(genpd, dev);
 	if (ret)
 		return ret;
 	genpd_stop_dev(genpd, dev);
 	return 0;
 }
 /**
  * pm_genpd_thaw_noirq - Early thaw of a device from an I/O power domain.
  * @dev: Device to thaw.
  *
  * Carry out an early thaw of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a power domain consisting of I/O
  * devices.
  */
 static int pm_genpd_thaw_noirq(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	if (genpd->suspend_power_off)
 		return 0;
 	genpd_start_dev(genpd, dev);
 	return genpd_thaw_early(genpd, dev);
 }
 /**
  * pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
  * @dev: Device to thaw.
  *
  * Thaw a device under the assumption that its pm_domain field points to the
  * domain member of an object of type struct generic_pm_domain representing
  * a power domain consisting of I/O devices.
  */
 static int pm_genpd_thaw(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	return genpd->suspend_power_off ? 0 : genpd_thaw_dev(genpd, dev);
 }
 /**
  * pm_genpd_restore_noirq - Early restore of a device from an I/O power domain.
  * @dev: Device to resume.
  *
  * Carry out an early restore of a device under the assumption that its
  * pm_domain field points to the domain member of an object of type
  * struct generic_pm_domain representing a power domain consisting of I/O
  * devices.
  */
 static int pm_genpd_restore_noirq(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return -EINVAL;
 	/*
 	 * Since all of the "noirq" callbacks are executed sequentially, it is
 	 * guaranteed that this function will never run twice in parallel for
 	 * the same PM domain, so it is not necessary to use locking here.
 	 */
 	genpd->status = GPD_STATE_POWER_OFF;
 	if (genpd->suspend_power_off) {
 		/*
 		 * The boot kernel might put the domain into the power on state,
 		 * so make sure it really is powered off.
 		 */
 		if (genpd->power_off)
 			genpd->power_off(genpd);
 		return 0;
 	}
 	pm_genpd_poweron(genpd);
 	genpd->suspended_count--;
 	genpd_start_dev(genpd, dev);
 	return genpd_resume_early(genpd, dev);
 }
 /**
  * pm_genpd_complete - Complete power transition of a device in a power domain.
  * @dev: Device to complete the transition of.
  *
  * Complete a power transition of a device (during a system-wide power
  * transition) under the assumption that its pm_domain field points to the
  * domain member of an object of type struct generic_pm_domain representing
  * a power domain consisting of I/O devices.
  */
 static void pm_genpd_complete(struct device *dev)
 {
 	struct generic_pm_domain *genpd;
 	bool run_complete;
 	dev_dbg(dev, "%s()\n", __func__);
 	genpd = dev_to_genpd(dev);
 	if (IS_ERR(genpd))
 		return;
 	mutex_lock(&genpd->lock);
 	run_complete = !genpd->suspend_power_off;
 	if (--genpd->prepared_count == 0)
 		genpd->suspend_power_off = false;
 	mutex_unlock(&genpd->lock);
 	if (run_complete) {
 		pm_generic_complete(dev);
 		pm_runtime_set_active(dev);
 		pm_runtime_enable(dev);
 		pm_runtime_idle(dev);
 	}
 }
 #else
 #define pm_genpd_prepare		NULL
 #define pm_genpd_suspend		NULL
 #define pm_genpd_suspend_noirq		NULL
 #define pm_genpd_resume_noirq		NULL
 #define pm_genpd_resume			NULL
 #define pm_genpd_freeze			NULL
 #define pm_genpd_freeze_noirq		NULL
 #define pm_genpd_thaw_noirq		NULL
 #define pm_genpd_thaw			NULL
 #define pm_genpd_restore_noirq		NULL
 #define pm_genpd_complete		NULL
 #endif /* CONFIG_PM_SLEEP */
 /**
  * __pm_genpd_add_device - Add a device to an I/O PM domain.
  * @genpd: PM domain to add the device to.
  * @dev: Device to be added.
  * @td: Set of PM QoS timing parameters to attach to the device.
  */
 int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
 			  struct gpd_timing_data *td)
 {
 	struct generic_pm_domain_data *gpd_data;
 	struct pm_domain_data *pdd;
 	int ret = 0;
 	dev_dbg(dev, "%s()\n", __func__);
 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
 		return -EINVAL;
 	genpd_acquire_lock(genpd);
 	if (genpd->status == GPD_STATE_POWER_OFF) {
 		ret = -EINVAL;
 		goto out;
 	}
 	if (genpd->prepared_count > 0) {
 		ret = -EAGAIN;
 		goto out;
 	}
 	list_for_each_entry(pdd, &genpd->dev_list, list_node)
 		if (pdd->dev == dev) {
 			ret = -EINVAL;
 			goto out;
 		}
 	gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
 	if (!gpd_data) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	genpd->device_count++;
 	dev->pm_domain = &genpd->domain;
 	dev_pm_get_subsys_data(dev);
 	dev->power.subsys_data->domain_data = &gpd_data->base;
 	gpd_data->base.dev = dev;
 	gpd_data->need_restore = false;
 	list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
 	if (td)
 		gpd_data->td = *td;
  out:
 	genpd_release_lock(genpd);
 	return ret;
 }
 /**
  * pm_genpd_remove_device - Remove a device from an I/O PM domain.
  * @genpd: PM domain to remove the device from.
  * @dev: Device to be removed.
  */
 int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 			   struct device *dev)
 {
 	struct pm_domain_data *pdd;
 	int ret = -EINVAL;
 	dev_dbg(dev, "%s()\n", __func__);
 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
 		return -EINVAL;
 	genpd_acquire_lock(genpd);
 	if (genpd->prepared_count > 0) {
 		ret = -EAGAIN;
 		goto out;
 	}
 	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
 		if (pdd->dev != dev)
 			continue;
 		list_del_init(&pdd->list_node);
 		pdd->dev = NULL;
 		dev_pm_put_subsys_data(dev);
 		dev->pm_domain = NULL;
 		kfree(to_gpd_data(pdd));
 		genpd->device_count--;
 		ret = 0;
 		break;
 	}
  out:
 	genpd_release_lock(genpd);
 	return ret;
 }
 /**
  * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
  * @genpd: Master PM domain to add the subdomain to.
  * @subdomain: Subdomain to be added.
  */
 int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
 			   struct generic_pm_domain *subdomain)
 {
 	struct gpd_link *link;
 	int ret = 0;
 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
 		return -EINVAL;
  start:
 	genpd_acquire_lock(genpd);
 	mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
 	if (subdomain->status != GPD_STATE_POWER_OFF
 	    && subdomain->status != GPD_STATE_ACTIVE) {
 		mutex_unlock(&subdomain->lock);
 		genpd_release_lock(genpd);
 		goto start;
 	}
 	if (genpd->status == GPD_STATE_POWER_OFF
 	    &&  subdomain->status != GPD_STATE_POWER_OFF) {
 		ret = -EINVAL;
 		goto out;
 	}
 	list_for_each_entry(link, &genpd->slave_links, slave_node) {
 		if (link->slave == subdomain && link->master == genpd) {
 			ret = -EINVAL;
 			goto out;
 		}
 	}
 	link = kzalloc(sizeof(*link), GFP_KERNEL);
 	if (!link) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	link->master = genpd;
 	list_add_tail(&link->master_node, &genpd->master_links);
 	link->slave = subdomain;
 	list_add_tail(&link->slave_node, &subdomain->slave_links);
 	if (subdomain->status != GPD_STATE_POWER_OFF)
 		genpd_sd_counter_inc(genpd);
  out:
 	mutex_unlock(&subdomain->lock);
 	genpd_release_lock(genpd);
 	return ret;
 }
 /**
  * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
  * @genpd: Master PM domain to remove the subdomain from.
  * @subdomain: Subdomain to be removed.
  */
 int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
 			      struct generic_pm_domain *subdomain)
 {
 	struct gpd_link *link;
 	int ret = -EINVAL;
 	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
 		return -EINVAL;
  start:
 	genpd_acquire_lock(genpd);
 	list_for_each_entry(link, &genpd->master_links, master_node) {
 		if (link->slave != subdomain)
 			continue;
 		mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
 		if (subdomain->status != GPD_STATE_POWER_OFF
 		    && subdomain->status != GPD_STATE_ACTIVE) {
 			mutex_unlock(&subdomain->lock);
 			genpd_release_lock(genpd);
 			goto start;
 		}
 		list_del(&link->master_node);
 		list_del(&link->slave_node);
 		kfree(link);
 		if (subdomain->status != GPD_STATE_POWER_OFF)
 			genpd_sd_counter_dec(genpd);
 		mutex_unlock(&subdomain->lock);
 		ret = 0;
 		break;
 	}
 	genpd_release_lock(genpd);
 	return ret;
 }
 /**
  * pm_genpd_add_callbacks - Add PM domain callbacks to a given device.
  * @dev: Device to add the callbacks to.
  * @ops: Set of callbacks to add.
  * @td: Timing data to add to the device along with the callbacks (optional).
  */
 int pm_genpd_add_callbacks(struct device *dev, struct gpd_dev_ops *ops,
 			   struct gpd_timing_data *td)
 {
 	struct pm_domain_data *pdd;
 	int ret = 0;
 	if (!(dev && dev->power.subsys_data && ops))
 		return -EINVAL;
 	pm_runtime_disable(dev);
 	device_pm_lock();
 	pdd = dev->power.subsys_data->domain_data;
 	if (pdd) {
 		struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
 		gpd_data->ops = *ops;
 		if (td)
 			gpd_data->td = *td;
 	} else {
 		ret = -EINVAL;
 	}
 	device_pm_unlock();
 	pm_runtime_enable(dev);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(pm_genpd_add_callbacks);
 /**
  * __pm_genpd_remove_callbacks - Remove PM domain callbacks from a given device.
  * @dev: Device to remove the callbacks from.
  * @clear_td: If set, clear the device's timing data too.
  */
 int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
 {
 	struct pm_domain_data *pdd;
 	int ret = 0;
 	if (!(dev && dev->power.subsys_data))
 		return -EINVAL;
 	pm_runtime_disable(dev);
 	device_pm_lock();
 	pdd = dev->power.subsys_data->domain_data;
 	if (pdd) {
 		struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
 		gpd_data->ops = (struct gpd_dev_ops){ 0 };
 		if (clear_td)
 			gpd_data->td = (struct gpd_timing_data){ 0 };
 	} else {
 		ret = -EINVAL;
 	}
 	device_pm_unlock();
 	pm_runtime_enable(dev);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(__pm_genpd_remove_callbacks);
 /* Default device callbacks for generic PM domains. */
 /**
  * pm_genpd_default_save_state - Default "save device state" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_save_state(struct device *dev)
 {
 	int (*cb)(struct device *__dev);
 	struct device_driver *drv = dev->driver;
 	cb = dev_gpd_data(dev)->ops.save_state;
 	if (cb)
 		return cb(dev);
 	if (drv && drv->pm && drv->pm->runtime_suspend)
 		return drv->pm->runtime_suspend(dev);
 	return 0;
 }
 /**
  * pm_genpd_default_restore_state - Default PM domians "restore device state".
  * @dev: Device to handle.
  */
 static int pm_genpd_default_restore_state(struct device *dev)
 {
 	int (*cb)(struct device *__dev);
 	struct device_driver *drv = dev->driver;
 	cb = dev_gpd_data(dev)->ops.restore_state;
 	if (cb)
 		return cb(dev);
 	if (drv && drv->pm && drv->pm->runtime_resume)
 		return drv->pm->runtime_resume(dev);
 	return 0;
 }
+#ifdef CONFIG_PM_SLEEP
 /**
  * pm_genpd_default_suspend - Default "device suspend" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_suspend(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend;
 	return cb ? cb(dev) : pm_generic_suspend(dev);
 }
 /**
  * pm_genpd_default_suspend_late - Default "late device suspend" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_suspend_late(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend_late;
 	return cb ? cb(dev) : pm_generic_suspend_noirq(dev);
 }
 /**
  * pm_genpd_default_resume_early - Default "early device resume" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_resume_early(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume_early;
 	return cb ? cb(dev) : pm_generic_resume_noirq(dev);
 }
 /**
  * pm_genpd_default_resume - Default "device resume" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_resume(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume;
 	return cb ? cb(dev) : pm_generic_resume(dev);
 }
 /**
  * pm_genpd_default_freeze - Default "device freeze" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_freeze(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze;
 	return cb ? cb(dev) : pm_generic_freeze(dev);
 }
 /**
  * pm_genpd_default_freeze_late - Default "late device freeze" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_freeze_late(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze_late;
 	return cb ? cb(dev) : pm_generic_freeze_noirq(dev);
 }
 /**
  * pm_genpd_default_thaw_early - Default "early device thaw" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_thaw_early(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw_early;
 	return cb ? cb(dev) : pm_generic_thaw_noirq(dev);
 }
 /**
  * pm_genpd_default_thaw - Default "device thaw" for PM domians.
  * @dev: Device to handle.
  */
 static int pm_genpd_default_thaw(struct device *dev)
 {
 	int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw;
 	return cb ? cb(dev) : pm_generic_thaw(dev);
 }
+#else /* !CONFIG_PM_SLEEP */
+#define pm_genpd_default_suspend	NULL
+#define pm_genpd_default_suspend_late	NULL
+#define pm_genpd_default_resume_early	NULL
+#define pm_genpd_default_resume		NULL
+#define pm_genpd_default_freeze		NULL
+#define pm_genpd_default_freeze_late	NULL
+#define pm_genpd_default_thaw_early	NULL
+#define pm_genpd_default_thaw		NULL
+#endif /* !CONFIG_PM_SLEEP */
 /**
  * pm_genpd_init - Initialize a generic I/O PM domain object.
  * @genpd: PM domain object to initialize.
  * @gov: PM domain governor to associate with the domain (may be NULL).
  * @is_off: Initial value of the domain's power_is_off field.
  */
 void pm_genpd_init(struct generic_pm_domain *genpd,
 		   struct dev_power_governor *gov, bool is_off)
 {
 	if (IS_ERR_OR_NULL(genpd))
 		return;
 	INIT_LIST_HEAD(&genpd->master_links);
 	INIT_LIST_HEAD(&genpd->slave_links);
 	INIT_LIST_HEAD(&genpd->dev_list);
 	mutex_init(&genpd->lock);
 	genpd->gov = gov;
 	INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
 	genpd->in_progress = 0;
 	atomic_set(&genpd->sd_count, 0);
 	genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
 	init_waitqueue_head(&genpd->status_wait_queue);
 	genpd->poweroff_task = NULL;
 	genpd->resume_count = 0;
 	genpd->device_count = 0;
 	genpd->suspended_count = 0;
 	genpd->max_off_time_ns = -1;
 	genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
 	genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
 	genpd->domain.ops.runtime_idle = pm_generic_runtime_idle;
 	genpd->domain.ops.prepare = pm_genpd_prepare;
 	genpd->domain.ops.suspend = pm_genpd_suspend;
 	genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
 	genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
 	genpd->domain.ops.resume = pm_genpd_resume;
 	genpd->domain.ops.freeze = pm_genpd_freeze;
 	genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
 	genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
 	genpd->domain.ops.thaw = pm_genpd_thaw;
 	genpd->domain.ops.poweroff = pm_genpd_suspend;
 	genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq;
 	genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
 	genpd->domain.ops.restore = pm_genpd_resume;
 	genpd->domain.ops.complete = pm_genpd_complete;
 	genpd->dev_ops.save_state = pm_genpd_default_save_state;
 	genpd->dev_ops.restore_state = pm_genpd_default_restore_state;
 	genpd->dev_ops.suspend = pm_genpd_default_suspend;
 	genpd->dev_ops.suspend_late = pm_genpd_default_suspend_late;
 	genpd->dev_ops.resume_early = pm_genpd_default_resume_early;
 	genpd->dev_ops.resume = pm_genpd_default_resume;
 	genpd->dev_ops.freeze = pm_genpd_default_freeze;
 	genpd->dev_ops.freeze_late = pm_genpd_default_freeze_late;
 	genpd->dev_ops.thaw_early = pm_genpd_default_thaw_early;
 	genpd->dev_ops.thaw = pm_genpd_default_thaw;
 	mutex_lock(&gpd_list_lock);
 	list_add(&genpd->gpd_list_node, &gpd_list);
 	mutex_unlock(&gpd_list_lock);
 }

drivers/base/power/domain_governor.c

Diff comments View file @ 9774040

 /*
  * drivers/base/power/domain_governor.c - Governors for device PM domains.
  *
  * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
  *
  * This file is released under the GPLv2.
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/pm_domain.h>
 #include <linux/pm_qos.h>
 #include <linux/hrtimer.h>
+#ifdef CONFIG_PM_RUNTIME
 /**
  * default_stop_ok - Default PM domain governor routine for stopping devices.
  * @dev: Device to check.
  */
 bool default_stop_ok(struct device *dev)
 {
 	struct gpd_timing_data *td = &dev_gpd_data(dev)->td;
 	dev_dbg(dev, "%s()\n", __func__);
 	if (dev->power.max_time_suspended_ns < 0 || td->break_even_ns == 0)
 		return true;
 	return td->stop_latency_ns + td->start_latency_ns < td->break_even_ns
 		&& td->break_even_ns < dev->power.max_time_suspended_ns;
 }
 /**
  * default_power_down_ok - Default generic PM domain power off governor routine.
  * @pd: PM domain to check.
  *
  * This routine must be executed under the PM domain's lock.
  */
 static bool default_power_down_ok(struct dev_pm_domain *pd)
 {
 	struct generic_pm_domain *genpd = pd_to_genpd(pd);
 	struct gpd_link *link;
 	struct pm_domain_data *pdd;
 	s64 min_dev_off_time_ns;
 	s64 off_on_time_ns;
 	ktime_t time_now = ktime_get();
 	off_on_time_ns = genpd->power_off_latency_ns +
 				genpd->power_on_latency_ns;
 	/*
 	 * It doesn't make sense to remove power from the domain if saving
 	 * the state of all devices in it and the power off/power on operations
 	 * take too much time.
 	 *
 	 * All devices in this domain have been stopped already at this point.
 	 */
 	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
 		if (pdd->dev->driver)
 			off_on_time_ns +=
 				to_gpd_data(pdd)->td.save_state_latency_ns;
 	}
 	/*
 	 * Check if subdomains can be off for enough time.
 	 *
 	 * All subdomains have been powered off already at this point.
 	 */
 	list_for_each_entry(link, &genpd->master_links, master_node) {
 		struct generic_pm_domain *sd = link->slave;
 		s64 sd_max_off_ns = sd->max_off_time_ns;
 		if (sd_max_off_ns < 0)
 			continue;
 		sd_max_off_ns -= ktime_to_ns(ktime_sub(time_now,
 						       sd->power_off_time));
 		/*
 		 * Check if the subdomain is allowed to be off long enough for
 		 * the current domain to turn off and on (that's how much time
 		 * it will have to wait worst case).
 		 */
 		if (sd_max_off_ns <= off_on_time_ns)
 			return false;
 	}
 	/*
 	 * Check if the devices in the domain can be off enough time.
 	 */
 	min_dev_off_time_ns = -1;
 	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
 		struct gpd_timing_data *td;
 		struct device *dev = pdd->dev;
 		s64 dev_off_time_ns;
 		if (!dev->driver || dev->power.max_time_suspended_ns < 0)
 			continue;
 		td = &to_gpd_data(pdd)->td;
 		dev_off_time_ns = dev->power.max_time_suspended_ns -
 			(td->start_latency_ns + td->restore_state_latency_ns +
 				ktime_to_ns(ktime_sub(time_now,
 						dev->power.suspend_time)));
 		if (dev_off_time_ns <= off_on_time_ns)
 			return false;
 		if (min_dev_off_time_ns > dev_off_time_ns
 		    || min_dev_off_time_ns < 0)
 			min_dev_off_time_ns = dev_off_time_ns;
 	}
 	if (min_dev_off_time_ns < 0) {
 		/*
 		 * There are no latency constraints, so the domain can spend
 		 * arbitrary time in the "off" state.
 		 */
 		genpd->max_off_time_ns = -1;
 		return true;
 	}
 	/*
 	 * The difference between the computed minimum delta and the time needed
 	 * to turn the domain on is the maximum theoretical time this domain can
 	 * spend in the "off" state.
 	 */
 	min_dev_off_time_ns -= genpd->power_on_latency_ns;
 	/*
 	 * If the difference between the computed minimum delta and the time
 	 * needed to turn the domain off and back on on is smaller than the
 	 * domain's power break even time, removing power from the domain is not
 	 * worth it.
 	 */
 	if (genpd->break_even_ns >
 	    min_dev_off_time_ns - genpd->power_off_latency_ns)
 		return false;
 	genpd->max_off_time_ns = min_dev_off_time_ns;
 	return true;
 }
-struct dev_power_governor simple_qos_governor = {
-	.stop_ok = default_stop_ok,
-	.power_down_ok = default_power_down_ok,
-};
 static bool always_on_power_down_ok(struct dev_pm_domain *domain)
 {
 	return false;
 }
+#else /* !CONFIG_PM_RUNTIME */
+bool default_stop_ok(struct device *dev)
+{
+	return false;
+}
+#define default_power_down_ok	NULL
+#define always_on_power_down_ok	NULL
+#endif /* !CONFIG_PM_RUNTIME */
+struct dev_power_governor simple_qos_governor = {
+	.stop_ok = default_stop_ok,
+	.power_down_ok = default_power_down_ok,
+};
 /**
  * pm_genpd_gov_always_on - A governor implementing an always-on policy
  */

kernel/Makefile

Diff comments View file @ 9774040

 #
 # Makefile for the linux kernel.
 #
 obj-y     = fork.o exec_domain.o panic.o printk.o \
 	    cpu.o exit.o itimer.o time.o softirq.o resource.o \
 	    sysctl.o sysctl_binary.o capability.o ptrace.o timer.o user.o \
 	    signal.o sys.o kmod.o workqueue.o pid.o \
 	    rcupdate.o extable.o params.o posix-timers.o \
 	    kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \
 	    hrtimer.o rwsem.o nsproxy.o srcu.o semaphore.o \
 	    notifier.o ksysfs.o cred.o \
 	    async.o range.o groups.o
 ifdef CONFIG_FUNCTION_TRACER
 # Do not trace debug files and internal ftrace files
 CFLAGS_REMOVE_lockdep.o = -pg
 CFLAGS_REMOVE_lockdep_proc.o = -pg
 CFLAGS_REMOVE_mutex-debug.o = -pg
 CFLAGS_REMOVE_rtmutex-debug.o = -pg
 CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_irq_work.o = -pg
 endif
 obj-y += sched/
+obj-y += power/
 obj-$(CONFIG_FREEZER) += freezer.o
 obj-$(CONFIG_PROFILING) += profile.o
 obj-$(CONFIG_SYSCTL_SYSCALL_CHECK) += sysctl_check.o
 obj-$(CONFIG_STACKTRACE) += stacktrace.o
 obj-y += time/
 obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
 obj-$(CONFIG_LOCKDEP) += lockdep.o
 ifeq ($(CONFIG_PROC_FS),y)
 obj-$(CONFIG_LOCKDEP) += lockdep_proc.o
 endif
 obj-$(CONFIG_FUTEX) += futex.o
 ifeq ($(CONFIG_COMPAT),y)
 obj-$(CONFIG_FUTEX) += futex_compat.o
 endif
 obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
 obj-$(CONFIG_DEBUG_RT_MUTEXES) += rtmutex-debug.o
 obj-$(CONFIG_RT_MUTEX_TESTER) += rtmutex-tester.o
 obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
 obj-$(CONFIG_SMP) += smp.o
 ifneq ($(CONFIG_SMP),y)
 obj-y += up.o
 endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_KALLSYMS) += kallsyms.o
-obj-$(CONFIG_PM) += power/
-obj-$(CONFIG_FREEZER) += power/
 obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
 obj-$(CONFIG_KEXEC) += kexec.o
 obj-$(CONFIG_BACKTRACE_SELF_TEST) += backtracetest.o
 obj-$(CONFIG_COMPAT) += compat.o
 obj-$(CONFIG_CGROUPS) += cgroup.o
 obj-$(CONFIG_CGROUP_FREEZER) += cgroup_freezer.o
 obj-$(CONFIG_CPUSETS) += cpuset.o
 obj-$(CONFIG_UTS_NS) += utsname.o
 obj-$(CONFIG_USER_NS) += user_namespace.o
 obj-$(CONFIG_PID_NS) += pid_namespace.o
 obj-$(CONFIG_IKCONFIG) += configs.o
 obj-$(CONFIG_RESOURCE_COUNTERS) += res_counter.o
 obj-$(CONFIG_SMP) += stop_machine.o
 obj-$(CONFIG_KPROBES_SANITY_TEST) += test_kprobes.o
 obj-$(CONFIG_AUDIT) += audit.o auditfilter.o
 obj-$(CONFIG_AUDITSYSCALL) += auditsc.o
 obj-$(CONFIG_AUDIT_WATCH) += audit_watch.o
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_KGDB) += debug/
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
 obj-$(CONFIG_LOCKUP_DETECTOR) += watchdog.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
 obj-$(CONFIG_TREE_RCU) += rcutree.o
 obj-$(CONFIG_TREE_PREEMPT_RCU) += rcutree.o
 obj-$(CONFIG_TREE_RCU_TRACE) += rcutree_trace.o
 obj-$(CONFIG_TINY_RCU) += rcutiny.o
 obj-$(CONFIG_TINY_PREEMPT_RCU) += rcutiny.o
 obj-$(CONFIG_RELAY) += relay.o
 obj-$(CONFIG_SYSCTL) += utsname_sysctl.o
 obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o
 obj-$(CONFIG_TASKSTATS) += taskstats.o tsacct.o
 obj-$(CONFIG_TRACEPOINTS) += tracepoint.o
 obj-$(CONFIG_LATENCYTOP) += latencytop.o
 obj-$(CONFIG_BINFMT_ELF) += elfcore.o
 obj-$(CONFIG_COMPAT_BINFMT_ELF) += elfcore.o
 obj-$(CONFIG_BINFMT_ELF_FDPIC) += elfcore.o
 obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_X86_DS) += trace/
 obj-$(CONFIG_RING_BUFFER) += trace/
 obj-$(CONFIG_TRACEPOINTS) += trace/
 obj-$(CONFIG_IRQ_WORK) += irq_work.o
 obj-$(CONFIG_CPU_PM) += cpu_pm.o
 obj-$(CONFIG_PERF_EVENTS) += events/
 obj-$(CONFIG_USER_RETURN_NOTIFIER) += user-return-notifier.o
 obj-$(CONFIG_PADATA) += padata.o
 obj-$(CONFIG_CRASH_DUMP) += crash_dump.o
 obj-$(CONFIG_JUMP_LABEL) += jump_label.o
 $(obj)/configs.o: $(obj)/config_data.h
 # config_data.h contains the same information as ikconfig.h but gzipped.
 # Info from config_data can be extracted from /proc/config*
 targets += config_data.gz
 $(obj)/config_data.gz: $(KCONFIG_CONFIG) FORCE
 	$(call if_changed,gzip)
       filechk_ikconfiggz = (echo "static const char kernel_config_data[] __used = MAGIC_START"; cat $< | scripts/bin2c; echo "MAGIC_END;")
 targets += config_data.h
 $(obj)/config_data.h: $(obj)/config_data.gz FORCE
 	$(call filechk,ikconfiggz)
 $(obj)/time.o: $(obj)/timeconst.h
 quiet_cmd_timeconst  = TIMEC   $@
       cmd_timeconst  = $(PERL) $< $(CONFIG_HZ) > $@
 targets += timeconst.h
 $(obj)/timeconst.h: $(src)/timeconst.pl FORCE
 	$(call if_changed,timeconst)

kernel/power/swap.c

Diff comments View file @ 9774040

 /*
  * linux/kernel/power/swap.c
  *
  * This file provides functions for reading the suspend image from
  * and writing it to a swap partition.
  *
  * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@ucw.cz>
  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
  * Copyright (C) 2010 Bojan Smojver <bojan@rexursive.com>
  *
  * This file is released under the GPLv2.
  *
  */
 #include <linux/module.h>
 #include <linux/file.h>
 #include <linux/delay.h>
 #include <linux/bitops.h>
 #include <linux/genhd.h>
 #include <linux/device.h>
 #include <linux/bio.h>
 #include <linux/blkdev.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
 #include <linux/pm.h>
 #include <linux/slab.h>
 #include <linux/lzo.h>
 #include <linux/vmalloc.h>
 #include <linux/cpumask.h>
 #include <linux/atomic.h>
 #include <linux/kthread.h>
 #include <linux/crc32.h>
 #include "power.h"
 #define HIBERNATE_SIG	"S1SUSPEND"
 /*
  *	The swap map is a data structure used for keeping track of each page
  *	written to a swap partition.  It consists of many swap_map_page
  *	structures that contain each an array of MAP_PAGE_ENTRIES swap entries.
  *	These structures are stored on the swap and linked together with the
  *	help of the .next_swap member.
  *
  *	The swap map is created during suspend.  The swap map pages are
  *	allocated and populated one at a time, so we only need one memory
  *	page to set up the entire structure.
  *
  *	During resume we pick up all swap_map_page structures into a list.
  */
 #define MAP_PAGE_ENTRIES	(PAGE_SIZE / sizeof(sector_t) - 1)
 struct swap_map_page {
 	sector_t entries[MAP_PAGE_ENTRIES];
 	sector_t next_swap;
 };
 struct swap_map_page_list {
 	struct swap_map_page *map;
 	struct swap_map_page_list *next;
 };
 /**
  *	The swap_map_handle structure is used for handling swap in
  *	a file-alike way
  */
 struct swap_map_handle {
 	struct swap_map_page *cur;
 	struct swap_map_page_list *maps;
 	sector_t cur_swap;
 	sector_t first_sector;
 	unsigned int k;
 	unsigned long nr_free_pages, written;
 	u32 crc32;
 };
 struct swsusp_header {
 	char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int) -
 	              sizeof(u32)];
 	u32	crc32;
 	sector_t image;
 	unsigned int flags;	/* Flags to pass to the "boot" kernel */
 	char	orig_sig[10];
 	char	sig[10];
 } __attribute__((packed));
 static struct swsusp_header *swsusp_header;
 /**
  *	The following functions are used for tracing the allocated
  *	swap pages, so that they can be freed in case of an error.
  */
 struct swsusp_extent {
 	struct rb_node node;
 	unsigned long start;
 	unsigned long end;
 };
 static struct rb_root swsusp_extents = RB_ROOT;
 static int swsusp_extents_insert(unsigned long swap_offset)
 {
 	struct rb_node **new = &(swsusp_extents.rb_node);
 	struct rb_node *parent = NULL;
 	struct swsusp_extent *ext;
 	/* Figure out where to put the new node */
 	while (*new) {
 		ext = container_of(*new, struct swsusp_extent, node);
 		parent = *new;
 		if (swap_offset < ext->start) {
 			/* Try to merge */
 			if (swap_offset == ext->start - 1) {
 				ext->start--;
 				return 0;
 			}
 			new = &((*new)->rb_left);
 		} else if (swap_offset > ext->end) {
 			/* Try to merge */
 			if (swap_offset == ext->end + 1) {
 				ext->end++;
 				return 0;
 			}
 			new = &((*new)->rb_right);
 		} else {
 			/* It already is in the tree */
 			return -EINVAL;
 		}
 	}
 	/* Add the new node and rebalance the tree. */
 	ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
 	if (!ext)
 		return -ENOMEM;
 	ext->start = swap_offset;
 	ext->end = swap_offset;
 	rb_link_node(&ext->node, parent, new);
 	rb_insert_color(&ext->node, &swsusp_extents);
 	return 0;
 }
 /**
  *	alloc_swapdev_block - allocate a swap page and register that it has
  *	been allocated, so that it can be freed in case of an error.
  */
 sector_t alloc_swapdev_block(int swap)
 {
 	unsigned long offset;
 	offset = swp_offset(get_swap_page_of_type(swap));
 	if (offset) {
 		if (swsusp_extents_insert(offset))
 			swap_free(swp_entry(swap, offset));
 		else
 			return swapdev_block(swap, offset);
 	}
 	return 0;
 }
 /**
  *	free_all_swap_pages - free swap pages allocated for saving image data.
  *	It also frees the extents used to register which swap entries had been
  *	allocated.
  */
 void free_all_swap_pages(int swap)
 {
 	struct rb_node *node;
 	while ((node = swsusp_extents.rb_node)) {
 		struct swsusp_extent *ext;
 		unsigned long offset;
 		ext = container_of(node, struct swsusp_extent, node);
 		rb_erase(node, &swsusp_extents);
 		for (offset = ext->start; offset <= ext->end; offset++)
 			swap_free(swp_entry(swap, offset));
 		kfree(ext);
 	}
 }
 int swsusp_swap_in_use(void)
 {
 	return (swsusp_extents.rb_node != NULL);
 }
 /*
  * General things
  */
 static unsigned short root_swap = 0xffff;
 struct block_device *hib_resume_bdev;
 /*
  * Saving part
  */
 static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
 {
 	int error;
 	hib_bio_read_page(swsusp_resume_block, swsusp_header, NULL);
 	if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
 	    !memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
 		memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
 		memcpy(swsusp_header->sig, HIBERNATE_SIG, 10);
 		swsusp_header->image = handle->first_sector;
 		swsusp_header->flags = flags;
 		if (flags & SF_CRC32_MODE)
 			swsusp_header->crc32 = handle->crc32;
 		error = hib_bio_write_page(swsusp_resume_block,
 					swsusp_header, NULL);
 	} else {
 		printk(KERN_ERR "PM: Swap header not found!\n");
 		error = -ENODEV;
 	}
 	return error;
 }
 /**
  *	swsusp_swap_check - check if the resume device is a swap device
  *	and get its index (if so)
  *
  *	This is called before saving image
  */
 static int swsusp_swap_check(void)
 {
 	int res;
 	res = swap_type_of(swsusp_resume_device, swsusp_resume_block,
 			&hib_resume_bdev);
 	if (res < 0)
 		return res;
 	root_swap = res;
 	res = blkdev_get(hib_resume_bdev, FMODE_WRITE, NULL);
 	if (res)
 		return res;
 	res = set_blocksize(hib_resume_bdev, PAGE_SIZE);
 	if (res < 0)
 		blkdev_put(hib_resume_bdev, FMODE_WRITE);
 	return res;
 }
 /**
  *	write_page - Write one page to given swap location.
  *	@buf:		Address we're writing.
  *	@offset:	Offset of the swap page we're writing to.
  *	@bio_chain:	Link the next write BIO here
  */
 static int write_page(void *buf, sector_t offset, struct bio **bio_chain)
 {
 	void *src;
 	int ret;
 	if (!offset)
 		return -ENOSPC;
 	if (bio_chain) {
 		src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
 		if (src) {
 			copy_page(src, buf);
 		} else {
 			ret = hib_wait_on_bio_chain(bio_chain); /* Free pages */
 			if (ret)
 				return ret;
 			src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
 			if (src) {
 				copy_page(src, buf);
 			} else {
 				WARN_ON_ONCE(1);
 				bio_chain = NULL;	/* Go synchronous */
 				src = buf;
 			}
 		}
 	} else {
 		src = buf;
 	}
 	return hib_bio_write_page(offset, src, bio_chain);
 }
 static void release_swap_writer(struct swap_map_handle *handle)
 {
 	if (handle->cur)
 		free_page((unsigned long)handle->cur);
 	handle->cur = NULL;
 }
 static int get_swap_writer(struct swap_map_handle *handle)
 {
 	int ret;
 	ret = swsusp_swap_check();
 	if (ret) {
 		if (ret != -ENOSPC)
 			printk(KERN_ERR "PM: Cannot find swap device, try "
 					"swapon -a.\n");
 		return ret;
 	}
 	handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
 	if (!handle->cur) {
 		ret = -ENOMEM;
 		goto err_close;
 	}
 	handle->cur_swap = alloc_swapdev_block(root_swap);
 	if (!handle->cur_swap) {
 		ret = -ENOSPC;
 		goto err_rel;
 	}
 	handle->k = 0;
 	handle->nr_free_pages = nr_free_pages() >> 1;
 	handle->written = 0;
 	handle->first_sector = handle->cur_swap;
 	return 0;
 err_rel:
 	release_swap_writer(handle);
 err_close:
 	swsusp_close(FMODE_WRITE);
 	return ret;
 }
 static int swap_write_page(struct swap_map_handle *handle, void *buf,
 				struct bio **bio_chain)
 {
 	int error = 0;
 	sector_t offset;
 	if (!handle->cur)
 		return -EINVAL;
 	offset = alloc_swapdev_block(root_swap);
 	error = write_page(buf, offset, bio_chain);
 	if (error)
 		return error;
 	handle->cur->entries[handle->k++] = offset;
 	if (handle->k >= MAP_PAGE_ENTRIES) {
 		offset = alloc_swapdev_block(root_swap);
 		if (!offset)
 			return -ENOSPC;
 		handle->cur->next_swap = offset;
 		error = write_page(handle->cur, handle->cur_swap, bio_chain);
 		if (error)
 			goto out;
 		clear_page(handle->cur);
 		handle->cur_swap = offset;
 		handle->k = 0;
 	}
 	if (bio_chain && ++handle->written > handle->nr_free_pages) {
 		error = hib_wait_on_bio_chain(bio_chain);
 		if (error)
 			goto out;
 		handle->written = 0;
 	}
  out:
 	return error;
 }
 static int flush_swap_writer(struct swap_map_handle *handle)
 {
 	if (handle->cur && handle->cur_swap)
 		return write_page(handle->cur, handle->cur_swap, NULL);
 	else
 		return -EINVAL;
 }
 static int swap_writer_finish(struct swap_map_handle *handle,
 		unsigned int flags, int error)
 {
 	if (!error) {
 		flush_swap_writer(handle);
 		printk(KERN_INFO "PM: S");
 		error = mark_swapfiles(handle, flags);
 		printk("|\n");
 	}
 	if (error)
 		free_all_swap_pages(root_swap);
 	release_swap_writer(handle);
 	swsusp_close(FMODE_WRITE);
 	return error;
 }
 /* We need to remember how much compressed data we need to read. */
 #define LZO_HEADER	sizeof(size_t)
 /* Number of pages/bytes we'll compress at one time. */
 #define LZO_UNC_PAGES	32
 #define LZO_UNC_SIZE	(LZO_UNC_PAGES * PAGE_SIZE)
 /* Number of pages/bytes we need for compressed data (worst case). */
 #define LZO_CMP_PAGES	DIV_ROUND_UP(lzo1x_worst_compress(LZO_UNC_SIZE) + \
 			             LZO_HEADER, PAGE_SIZE)
 #define LZO_CMP_SIZE	(LZO_CMP_PAGES * PAGE_SIZE)
 /* Maximum number of threads for compression/decompression. */
 #define LZO_THREADS	3
 /* Maximum number of pages for read buffering. */
 #define LZO_READ_PAGES	(MAP_PAGE_ENTRIES * 8)
 /**
  *	save_image - save the suspend image data
  */
 static int save_image(struct swap_map_handle *handle,
                       struct snapshot_handle *snapshot,
                       unsigned int nr_to_write)
 {
 	unsigned int m;
 	int ret;
 	int nr_pages;
 	int err2;
 	struct bio *bio;
 	struct timeval start;
 	struct timeval stop;
 	printk(KERN_INFO "PM: Saving image data pages (%u pages) ...     ",
 		nr_to_write);
 	m = nr_to_write / 100;
 	if (!m)
 		m = 1;
 	nr_pages = 0;
 	bio = NULL;
 	do_gettimeofday(&start);
 	while (1) {
 		ret = snapshot_read_next(snapshot);
 		if (ret <= 0)
 			break;
 		ret = swap_write_page(handle, data_of(*snapshot), &bio);
 		if (ret)
 			break;
 		if (!(nr_pages % m))
 			printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
 		nr_pages++;
 	}
 	err2 = hib_wait_on_bio_chain(&bio);
 	do_gettimeofday(&stop);
 	if (!ret)
 		ret = err2;
 	if (!ret)
 		printk(KERN_CONT "\b\b\b\bdone\n");
 	else
 		printk(KERN_CONT "\n");
 	swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
 	return ret;
 }
 /**
  * Structure used for CRC32.
  */
 struct crc_data {
 	struct task_struct *thr;                  /* thread */
 	atomic_t ready;                           /* ready to start flag */
 	atomic_t stop;                            /* ready to stop flag */
 	unsigned run_threads;                     /* nr current threads */
 	wait_queue_head_t go;                     /* start crc update */
 	wait_queue_head_t done;                   /* crc update done */
 	u32 *crc32;                               /* points to handle's crc32 */
 	size_t *unc_len[LZO_THREADS];             /* uncompressed lengths */
 	unsigned char *unc[LZO_THREADS];          /* uncompressed data */
 };
 /**
  * CRC32 update function that runs in its own thread.
  */
 static int crc32_threadfn(void *data)
 {
 	struct crc_data *d = data;
 	unsigned i;
 	while (1) {
 		wait_event(d->go, atomic_read(&d->ready) ||
 		                  kthread_should_stop());
 		if (kthread_should_stop()) {
 			d->thr = NULL;
 			atomic_set(&d->stop, 1);
 			wake_up(&d->done);
 			break;
 		}
 		atomic_set(&d->ready, 0);
 		for (i = 0; i < d->run_threads; i++)
 			*d->crc32 = crc32_le(*d->crc32,
 			                     d->unc[i], *d->unc_len[i]);
 		atomic_set(&d->stop, 1);
 		wake_up(&d->done);
 	}
 	return 0;
 }
 /**
  * Structure used for LZO data compression.
  */
 struct cmp_data {
 	struct task_struct *thr;                  /* thread */
 	atomic_t ready;                           /* ready to start flag */
 	atomic_t stop;                            /* ready to stop flag */
 	int ret;                                  /* return code */
 	wait_queue_head_t go;                     /* start compression */
 	wait_queue_head_t done;                   /* compression done */
 	size_t unc_len;                           /* uncompressed length */
 	size_t cmp_len;                           /* compressed length */
 	unsigned char unc[LZO_UNC_SIZE];          /* uncompressed buffer */
 	unsigned char cmp[LZO_CMP_SIZE];          /* compressed buffer */
 	unsigned char wrk[LZO1X_1_MEM_COMPRESS];  /* compression workspace */
 };
 /**
  * Compression function that runs in its own thread.
  */
 static int lzo_compress_threadfn(void *data)
 {
 	struct cmp_data *d = data;
 	while (1) {
 		wait_event(d->go, atomic_read(&d->ready) ||
 		                  kthread_should_stop());
 		if (kthread_should_stop()) {
 			d->thr = NULL;
 			d->ret = -1;
 			atomic_set(&d->stop, 1);
 			wake_up(&d->done);
 			break;
 		}
 		atomic_set(&d->ready, 0);
 		d->ret = lzo1x_1_compress(d->unc, d->unc_len,
 		                          d->cmp + LZO_HEADER, &d->cmp_len,
 		                          d->wrk);
 		atomic_set(&d->stop, 1);
 		wake_up(&d->done);
 	}
 	return 0;
 }
 /**
  * save_image_lzo - Save the suspend image data compressed with LZO.
  * @handle: Swap mam handle to use for saving the image.
  * @snapshot: Image to read data from.
  * @nr_to_write: Number of pages to save.
  */
 static int save_image_lzo(struct swap_map_handle *handle,
                           struct snapshot_handle *snapshot,
                           unsigned int nr_to_write)
 {
 	unsigned int m;
 	int ret = 0;
 	int nr_pages;
 	int err2;
 	struct bio *bio;
 	struct timeval start;
 	struct timeval stop;
 	size_t off;
 	unsigned thr, run_threads, nr_threads;
 	unsigned char *page = NULL;
 	struct cmp_data *data = NULL;
 	struct crc_data *crc = NULL;
 	/*
 	 * We'll limit the number of threads for compression to limit memory
 	 * footprint.
 	 */
 	nr_threads = num_online_cpus() - 1;
 	nr_threads = clamp_val(nr_threads, 1, LZO_THREADS);
 	page = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
 	if (!page) {
 		printk(KERN_ERR "PM: Failed to allocate LZO page\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	data = vmalloc(sizeof(*data) * nr_threads);
 	if (!data) {
 		printk(KERN_ERR "PM: Failed to allocate LZO data\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	for (thr = 0; thr < nr_threads; thr++)
 		memset(&data[thr], 0, offsetof(struct cmp_data, go));
 	crc = kmalloc(sizeof(*crc), GFP_KERNEL);
 	if (!crc) {
 		printk(KERN_ERR "PM: Failed to allocate crc\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	memset(crc, 0, offsetof(struct crc_data, go));
 	/*
 	 * Start the compression threads.
 	 */
 	for (thr = 0; thr < nr_threads; thr++) {
 		init_waitqueue_head(&data[thr].go);
 		init_waitqueue_head(&data[thr].done);
 		data[thr].thr = kthread_run(lzo_compress_threadfn,
 		                            &data[thr],
 		                            "image_compress/%u", thr);
 		if (IS_ERR(data[thr].thr)) {
 			data[thr].thr = NULL;
 			printk(KERN_ERR
 			       "PM: Cannot start compression threads\n");
 			ret = -ENOMEM;
 			goto out_clean;
 		}
 	}
 	/*
 	 * Adjust number of free pages after all allocations have been done.
 	 * We don't want to run out of pages when writing.
 	 */
 	handle->nr_free_pages = nr_free_pages() >> 1;
 	/*
 	 * Start the CRC32 thread.
 	 */
 	init_waitqueue_head(&crc->go);
 	init_waitqueue_head(&crc->done);
 	handle->crc32 = 0;
 	crc->crc32 = &handle->crc32;
 	for (thr = 0; thr < nr_threads; thr++) {
 		crc->unc[thr] = data[thr].unc;
 		crc->unc_len[thr] = &data[thr].unc_len;
 	}
 	crc->thr = kthread_run(crc32_threadfn, crc, "image_crc32");
 	if (IS_ERR(crc->thr)) {
 		crc->thr = NULL;
 		printk(KERN_ERR "PM: Cannot start CRC32 thread\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	printk(KERN_INFO
 		"PM: Using %u thread(s) for compression.\n"
 		"PM: Compressing and saving image data (%u pages) ...     ",
 		nr_threads, nr_to_write);
 	m = nr_to_write / 100;
 	if (!m)
 		m = 1;
 	nr_pages = 0;
 	bio = NULL;
 	do_gettimeofday(&start);
 	for (;;) {
 		for (thr = 0; thr < nr_threads; thr++) {
 			for (off = 0; off < LZO_UNC_SIZE; off += PAGE_SIZE) {
 				ret = snapshot_read_next(snapshot);
 				if (ret < 0)
 					goto out_finish;
 				if (!ret)
 					break;
 				memcpy(data[thr].unc + off,
 				       data_of(*snapshot), PAGE_SIZE);
 				if (!(nr_pages % m))
 					printk(KERN_CONT "\b\b\b\b%3d%%",
 				               nr_pages / m);
 				nr_pages++;
 			}
 			if (!off)
 				break;
 			data[thr].unc_len = off;
 			atomic_set(&data[thr].ready, 1);
 			wake_up(&data[thr].go);
 		}
 		if (!thr)
 			break;
 		crc->run_threads = thr;
 		atomic_set(&crc->ready, 1);
 		wake_up(&crc->go);
 		for (run_threads = thr, thr = 0; thr < run_threads; thr++) {
 			wait_event(data[thr].done,
 			           atomic_read(&data[thr].stop));
 			atomic_set(&data[thr].stop, 0);
 			ret = data[thr].ret;
 			if (ret < 0) {
 				printk(KERN_ERR "PM: LZO compression failed\n");
 				goto out_finish;
 			}
 			if (unlikely(!data[thr].cmp_len ||
 			             data[thr].cmp_len >
 			             lzo1x_worst_compress(data[thr].unc_len))) {
 				printk(KERN_ERR
 				       "PM: Invalid LZO compressed length\n");
 				ret = -1;
 				goto out_finish;
 			}
 			*(size_t *)data[thr].cmp = data[thr].cmp_len;
 			/*
 			 * Given we are writing one page at a time to disk, we
 			 * copy that much from the buffer, although the last
 			 * bit will likely be smaller than full page. This is
 			 * OK - we saved the length of the compressed data, so
 			 * any garbage at the end will be discarded when we
 			 * read it.
 			 */
 			for (off = 0;
 			     off < LZO_HEADER + data[thr].cmp_len;
 			     off += PAGE_SIZE) {
 				memcpy(page, data[thr].cmp + off, PAGE_SIZE);
 				ret = swap_write_page(handle, page, &bio);
 				if (ret)
 					goto out_finish;
 			}
 		}
 		wait_event(crc->done, atomic_read(&crc->stop));
 		atomic_set(&crc->stop, 0);
 	}
 out_finish:
 	err2 = hib_wait_on_bio_chain(&bio);
 	do_gettimeofday(&stop);
 	if (!ret)
 		ret = err2;
 	if (!ret) {
 		printk(KERN_CONT "\b\b\b\bdone\n");
 	} else {
 		printk(KERN_CONT "\n");
 	}
 	swsusp_show_speed(&start, &stop, nr_to_write, "Wrote");
 out_clean:
 	if (crc) {
 		if (crc->thr)
 			kthread_stop(crc->thr);
 		kfree(crc);
 	}
 	if (data) {
 		for (thr = 0; thr < nr_threads; thr++)
 			if (data[thr].thr)
 				kthread_stop(data[thr].thr);
 		vfree(data);
 	}
 	if (page) free_page((unsigned long)page);
 	return ret;
 }
 /**
  *	enough_swap - Make sure we have enough swap to save the image.
  *
  *	Returns TRUE or FALSE after checking the total amount of swap
  *	space avaiable from the resume partition.
  */
 static int enough_swap(unsigned int nr_pages, unsigned int flags)
 {
 	unsigned int free_swap = count_swap_pages(root_swap, 1);
 	unsigned int required;
 	pr_debug("PM: Free swap pages: %u\n", free_swap);
-	required = PAGES_FOR_IO + ((flags & SF_NOCOMPRESS_MODE) ?
+	required = PAGES_FOR_IO + nr_pages;
-		nr_pages : (nr_pages * LZO_CMP_PAGES) / LZO_UNC_PAGES + 1);
 	return free_swap > required;
 }
 /**
  *	swsusp_write - Write entire image and metadata.
  *	@flags: flags to pass to the "boot" kernel in the image header
  *
  *	It is important _NOT_ to umount filesystems at this point. We want
  *	them synced (in case something goes wrong) but we DO not want to mark
  *	filesystem clean: it is not. (And it does not matter, if we resume
  *	correctly, we'll mark system clean, anyway.)
  */
 int swsusp_write(unsigned int flags)
 {
 	struct swap_map_handle handle;
 	struct snapshot_handle snapshot;
 	struct swsusp_info *header;
 	unsigned long pages;
 	int error;
 	pages = snapshot_get_image_size();
 	error = get_swap_writer(&handle);
 	if (error) {
 		printk(KERN_ERR "PM: Cannot get swap writer\n");
 		return error;
 	}
-	if (!enough_swap(pages, flags)) {
+	if (flags & SF_NOCOMPRESS_MODE) {
-		printk(KERN_ERR "PM: Not enough free swap\n");
+		if (!enough_swap(pages, flags)) {
-		error = -ENOSPC;
+			printk(KERN_ERR "PM: Not enough free swap\n");
-		goto out_finish;
+			error = -ENOSPC;
+			goto out_finish;
+		}
 	}
 	memset(&snapshot, 0, sizeof(struct snapshot_handle));
 	error = snapshot_read_next(&snapshot);
 	if (error < PAGE_SIZE) {
 		if (error >= 0)
 			error = -EFAULT;
 		goto out_finish;
 	}
 	header = (struct swsusp_info *)data_of(snapshot);
 	error = swap_write_page(&handle, header, NULL);
 	if (!error) {
 		error = (flags & SF_NOCOMPRESS_MODE) ?
 			save_image(&handle, &snapshot, pages - 1) :
 			save_image_lzo(&handle, &snapshot, pages - 1);
 	}
 out_finish:
 	error = swap_writer_finish(&handle, flags, error);
 	return error;
 }
 /**
  *	The following functions allow us to read data using a swap map
  *	in a file-alike way
  */
 static void release_swap_reader(struct swap_map_handle *handle)
 {
 	struct swap_map_page_list *tmp;
 	while (handle->maps) {
 		if (handle->maps->map)
 			free_page((unsigned long)handle->maps->map);
 		tmp = handle->maps;
 		handle->maps = handle->maps->next;
 		kfree(tmp);
 	}
 	handle->cur = NULL;
 }
 static int get_swap_reader(struct swap_map_handle *handle,
 		unsigned int *flags_p)
 {
 	int error;
 	struct swap_map_page_list *tmp, *last;
 	sector_t offset;
 	*flags_p = swsusp_header->flags;
 	if (!swsusp_header->image) /* how can this happen? */
 		return -EINVAL;
 	handle->cur = NULL;
 	last = handle->maps = NULL;
 	offset = swsusp_header->image;
 	while (offset) {
 		tmp = kmalloc(sizeof(*handle->maps), GFP_KERNEL);
 		if (!tmp) {
 			release_swap_reader(handle);
 			return -ENOMEM;
 		}
 		memset(tmp, 0, sizeof(*tmp));
 		if (!handle->maps)
 			handle->maps = tmp;
 		if (last)
 			last->next = tmp;
 		last = tmp;
 		tmp->map = (struct swap_map_page *)
 		           __get_free_page(__GFP_WAIT | __GFP_HIGH);
 		if (!tmp->map) {
 			release_swap_reader(handle);
 			return -ENOMEM;
 		}
 		error = hib_bio_read_page(offset, tmp->map, NULL);
 		if (error) {
 			release_swap_reader(handle);
 			return error;
 		}
 		offset = tmp->map->next_swap;
 	}
 	handle->k = 0;
 	handle->cur = handle->maps->map;
 	return 0;
 }
 static int swap_read_page(struct swap_map_handle *handle, void *buf,
 				struct bio **bio_chain)
 {
 	sector_t offset;
 	int error;
 	struct swap_map_page_list *tmp;
 	if (!handle->cur)
 		return -EINVAL;
 	offset = handle->cur->entries[handle->k];
 	if (!offset)
 		return -EFAULT;
 	error = hib_bio_read_page(offset, buf, bio_chain);
 	if (error)
 		return error;
 	if (++handle->k >= MAP_PAGE_ENTRIES) {
 		handle->k = 0;
 		free_page((unsigned long)handle->maps->map);
 		tmp = handle->maps;
 		handle->maps = handle->maps->next;
 		kfree(tmp);
 		if (!handle->maps)
 			release_swap_reader(handle);
 		else
 			handle->cur = handle->maps->map;
 	}
 	return error;
 }
 static int swap_reader_finish(struct swap_map_handle *handle)
 {
 	release_swap_reader(handle);
 	return 0;
 }
 /**
  *	load_image - load the image using the swap map handle
  *	@handle and the snapshot handle @snapshot
  *	(assume there are @nr_pages pages to load)
  */
 static int load_image(struct swap_map_handle *handle,
                       struct snapshot_handle *snapshot,
                       unsigned int nr_to_read)
 {
 	unsigned int m;
 	int ret = 0;
 	struct timeval start;
 	struct timeval stop;
 	struct bio *bio;
 	int err2;
 	unsigned nr_pages;
 	printk(KERN_INFO "PM: Loading image data pages (%u pages) ...     ",
 		nr_to_read);
 	m = nr_to_read / 100;
 	if (!m)
 		m = 1;
 	nr_pages = 0;
 	bio = NULL;
 	do_gettimeofday(&start);
 	for ( ; ; ) {
 		ret = snapshot_write_next(snapshot);
 		if (ret <= 0)
 			break;
 		ret = swap_read_page(handle, data_of(*snapshot), &bio);
 		if (ret)
 			break;
 		if (snapshot->sync_read)
 			ret = hib_wait_on_bio_chain(&bio);
 		if (ret)
 			break;
 		if (!(nr_pages % m))
 			printk("\b\b\b\b%3d%%", nr_pages / m);
 		nr_pages++;
 	}
 	err2 = hib_wait_on_bio_chain(&bio);
 	do_gettimeofday(&stop);
 	if (!ret)
 		ret = err2;
 	if (!ret) {
 		printk("\b\b\b\bdone\n");
 		snapshot_write_finalize(snapshot);
 		if (!snapshot_image_loaded(snapshot))
 			ret = -ENODATA;
 	} else
 		printk("\n");
 	swsusp_show_speed(&start, &stop, nr_to_read, "Read");
 	return ret;
 }
 /**
  * Structure used for LZO data decompression.
  */
 struct dec_data {
 	struct task_struct *thr;                  /* thread */
 	atomic_t ready;                           /* ready to start flag */
 	atomic_t stop;                            /* ready to stop flag */
 	int ret;                                  /* return code */
 	wait_queue_head_t go;                     /* start decompression */
 	wait_queue_head_t done;                   /* decompression done */
 	size_t unc_len;                           /* uncompressed length */
 	size_t cmp_len;                           /* compressed length */
 	unsigned char unc[LZO_UNC_SIZE];          /* uncompressed buffer */
 	unsigned char cmp[LZO_CMP_SIZE];          /* compressed buffer */
 };
 /**
  * Deompression function that runs in its own thread.
  */
 static int lzo_decompress_threadfn(void *data)
 {
 	struct dec_data *d = data;
 	while (1) {
 		wait_event(d->go, atomic_read(&d->ready) ||
 		                  kthread_should_stop());
 		if (kthread_should_stop()) {
 			d->thr = NULL;
 			d->ret = -1;
 			atomic_set(&d->stop, 1);
 			wake_up(&d->done);
 			break;
 		}
 		atomic_set(&d->ready, 0);
 		d->unc_len = LZO_UNC_SIZE;
 		d->ret = lzo1x_decompress_safe(d->cmp + LZO_HEADER, d->cmp_len,
 		                               d->unc, &d->unc_len);
 		atomic_set(&d->stop, 1);
 		wake_up(&d->done);
 	}
 	return 0;
 }
 /**
  * load_image_lzo - Load compressed image data and decompress them with LZO.
  * @handle: Swap map handle to use for loading data.
  * @snapshot: Image to copy uncompressed data into.
  * @nr_to_read: Number of pages to load.
  */
 static int load_image_lzo(struct swap_map_handle *handle,
                           struct snapshot_handle *snapshot,
                           unsigned int nr_to_read)
 {
 	unsigned int m;
 	int ret = 0;
 	int eof = 0;
 	struct bio *bio;
 	struct timeval start;
 	struct timeval stop;
 	unsigned nr_pages;
 	size_t off;
 	unsigned i, thr, run_threads, nr_threads;
 	unsigned ring = 0, pg = 0, ring_size = 0,
 	         have = 0, want, need, asked = 0;
 	unsigned long read_pages;
 	unsigned char **page = NULL;
 	struct dec_data *data = NULL;
 	struct crc_data *crc = NULL;
 	/*
 	 * We'll limit the number of threads for decompression to limit memory
 	 * footprint.
 	 */
 	nr_threads = num_online_cpus() - 1;
 	nr_threads = clamp_val(nr_threads, 1, LZO_THREADS);
 	page = vmalloc(sizeof(*page) * LZO_READ_PAGES);
 	if (!page) {
 		printk(KERN_ERR "PM: Failed to allocate LZO page\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	data = vmalloc(sizeof(*data) * nr_threads);
 	if (!data) {
 		printk(KERN_ERR "PM: Failed to allocate LZO data\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	for (thr = 0; thr < nr_threads; thr++)
 		memset(&data[thr], 0, offsetof(struct dec_data, go));
 	crc = kmalloc(sizeof(*crc), GFP_KERNEL);
 	if (!crc) {
 		printk(KERN_ERR "PM: Failed to allocate crc\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	memset(crc, 0, offsetof(struct crc_data, go));
 	/*
 	 * Start the decompression threads.
 	 */
 	for (thr = 0; thr < nr_threads; thr++) {
 		init_waitqueue_head(&data[thr].go);
 		init_waitqueue_head(&data[thr].done);
 		data[thr].thr = kthread_run(lzo_decompress_threadfn,
 		                            &data[thr],
 		                            "image_decompress/%u", thr);
 		if (IS_ERR(data[thr].thr)) {
 			data[thr].thr = NULL;
 			printk(KERN_ERR
 			       "PM: Cannot start decompression threads\n");
 			ret = -ENOMEM;
 			goto out_clean;
 		}
 	}
 	/*
 	 * Start the CRC32 thread.
 	 */
 	init_waitqueue_head(&crc->go);
 	init_waitqueue_head(&crc->done);
 	handle->crc32 = 0;
 	crc->crc32 = &handle->crc32;
 	for (thr = 0; thr < nr_threads; thr++) {
 		crc->unc[thr] = data[thr].unc;
 		crc->unc_len[thr] = &data[thr].unc_len;
 	}
 	crc->thr = kthread_run(crc32_threadfn, crc, "image_crc32");
 	if (IS_ERR(crc->thr)) {
 		crc->thr = NULL;
 		printk(KERN_ERR "PM: Cannot start CRC32 thread\n");
 		ret = -ENOMEM;
 		goto out_clean;
 	}
 	/*
 	 * Adjust number of pages for read buffering, in case we are short.
 	 */
 	read_pages = (nr_free_pages() - snapshot_get_image_size()) >> 1;
 	read_pages = clamp_val(read_pages, LZO_CMP_PAGES, LZO_READ_PAGES);
 	for (i = 0; i < read_pages; i++) {
 		page[i] = (void *)__get_free_page(i < LZO_CMP_PAGES ?
 		                                  __GFP_WAIT | __GFP_HIGH :
 		                                  __GFP_WAIT);
 		if (!page[i]) {
 			if (i < LZO_CMP_PAGES) {
 				ring_size = i;
 				printk(KERN_ERR
 				       "PM: Failed to allocate LZO pages\n");
 				ret = -ENOMEM;
 				goto out_clean;
 			} else {
 				break;
 			}
 		}
 	}
 	want = ring_size = i;
 	printk(KERN_INFO
 		"PM: Using %u thread(s) for decompression.\n"
 		"PM: Loading and decompressing image data (%u pages) ...     ",
 		nr_threads, nr_to_read);
 	m = nr_to_read / 100;
 	if (!m)
 		m = 1;
 	nr_pages = 0;
 	bio = NULL;
 	do_gettimeofday(&start);
 	ret = snapshot_write_next(snapshot);
 	if (ret <= 0)
 		goto out_finish;
 	for(;;) {
 		for (i = 0; !eof && i < want; i++) {
 			ret = swap_read_page(handle, page[ring], &bio);
 			if (ret) {
 				/*
 				 * On real read error, finish. On end of data,
 				 * set EOF flag and just exit the read loop.
 				 */
 				if (handle->cur &&
 				    handle->cur->entries[handle->k]) {
 					goto out_finish;
 				} else {
 					eof = 1;
 					break;
 				}
 			}
 			if (++ring >= ring_size)
 				ring = 0;
 		}
 		asked += i;
 		want -= i;
 		/*
 		 * We are out of data, wait for some more.
 		 */
 		if (!have) {
 			if (!asked)
 				break;
 			ret = hib_wait_on_bio_chain(&bio);
 			if (ret)
 				goto out_finish;
 			have += asked;
 			asked = 0;
 			if (eof)
 				eof = 2;
 		}
 		if (crc->run_threads) {
 			wait_event(crc->done, atomic_read(&crc->stop));
 			atomic_set(&crc->stop, 0);
 			crc->run_threads = 0;
 		}
 		for (thr = 0; have && thr < nr_threads; thr++) {
 			data[thr].cmp_len = *(size_t *)page[pg];
 			if (unlikely(!data[thr].cmp_len ||
 			             data[thr].cmp_len >
 			             lzo1x_worst_compress(LZO_UNC_SIZE))) {
 				printk(KERN_ERR
 				       "PM: Invalid LZO compressed length\n");
 				ret = -1;
 				goto out_finish;
 			}
 			need = DIV_ROUND_UP(data[thr].cmp_len + LZO_HEADER,
 			                    PAGE_SIZE);
 			if (need > have) {
 				if (eof > 1) {
 					ret = -1;
 					goto out_finish;
 				}
 				break;
 			}
 			for (off = 0;
 			     off < LZO_HEADER + data[thr].cmp_len;
 			     off += PAGE_SIZE) {
 				memcpy(data[thr].cmp + off,
 				       page[pg], PAGE_SIZE);
 				have--;
 				want++;
 				if (++pg >= ring_size)
 					pg = 0;
 			}
 			atomic_set(&data[thr].ready, 1);
 			wake_up(&data[thr].go);
 		}
 		/*
 		 * Wait for more data while we are decompressing.
 		 */
 		if (have < LZO_CMP_PAGES && asked) {
 			ret = hib_wait_on_bio_chain(&bio);
 			if (ret)
 				goto out_finish;
 			have += asked;
 			asked = 0;
 			if (eof)
 				eof = 2;
 		}
 		for (run_threads = thr, thr = 0; thr < run_threads; thr++) {
 			wait_event(data[thr].done,
 			           atomic_read(&data[thr].stop));
 			atomic_set(&data[thr].stop, 0);
 			ret = data[thr].ret;
 			if (ret < 0) {
 				printk(KERN_ERR
 				       "PM: LZO decompression failed\n");
 				goto out_finish;
 			}
 			if (unlikely(!data[thr].unc_len ||
 			             data[thr].unc_len > LZO_UNC_SIZE ||
 			             data[thr].unc_len & (PAGE_SIZE - 1))) {
 				printk(KERN_ERR
 				       "PM: Invalid LZO uncompressed length\n");
 				ret = -1;
 				goto out_finish;
 			}
 			for (off = 0;
 			     off < data[thr].unc_len; off += PAGE_SIZE) {
 				memcpy(data_of(*snapshot),
 				       data[thr].unc + off, PAGE_SIZE);
 				if (!(nr_pages % m))
 					printk("\b\b\b\b%3d%%", nr_pages / m);
 				nr_pages++;
 				ret = snapshot_write_next(snapshot);
 				if (ret <= 0) {
 					crc->run_threads = thr + 1;
 					atomic_set(&crc->ready, 1);
 					wake_up(&crc->go);
 					goto out_finish;
 				}
 			}
 		}
 		crc->run_threads = thr;
 		atomic_set(&crc->ready, 1);
 		wake_up(&crc->go);
 	}
 out_finish:
 	if (crc->run_threads) {
 		wait_event(crc->done, atomic_read(&crc->stop));
 		atomic_set(&crc->stop, 0);
 	}
 	do_gettimeofday(&stop);
 	if (!ret) {
 		printk("\b\b\b\bdone\n");
 		snapshot_write_finalize(snapshot);
 		if (!snapshot_image_loaded(snapshot))
 			ret = -ENODATA;
 		if (!ret) {
 			if (swsusp_header->flags & SF_CRC32_MODE) {
 				if(handle->crc32 != swsusp_header->crc32) {
 					printk(KERN_ERR
 					       "PM: Invalid image CRC32!\n");
 					ret = -ENODATA;
 				}
 			}
 		}
 	} else
 		printk("\n");
 	swsusp_show_speed(&start, &stop, nr_to_read, "Read");
 out_clean:
 	for (i = 0; i < ring_size; i++)
 		free_page((unsigned long)page[i]);
 	if (crc) {
 		if (crc->thr)
 			kthread_stop(crc->thr);
 		kfree(crc);
 	}
 	if (data) {
 		for (thr = 0; thr < nr_threads; thr++)
 			if (data[thr].thr)
 				kthread_stop(data[thr].thr);
 		vfree(data);
 	}
 	if (page) vfree(page);
 	return ret;
 }
 /**
  *	swsusp_read - read the hibernation image.
  *	@flags_p: flags passed by the "frozen" kernel in the image header should
  *		  be written into this memory location
  */
 int swsusp_read(unsigned int *flags_p)
 {
 	int error;
 	struct swap_map_handle handle;
 	struct snapshot_handle snapshot;
 	struct swsusp_info *header;
 	memset(&snapshot, 0, sizeof(struct snapshot_handle));
 	error = snapshot_write_next(&snapshot);
 	if (error < PAGE_SIZE)
 		return error < 0 ? error : -EFAULT;
 	header = (struct swsusp_info *)data_of(snapshot);
 	error = get_swap_reader(&handle, flags_p);
 	if (error)
 		goto end;
 	if (!error)
 		error = swap_read_page(&handle, header, NULL);
 	if (!error) {
 		error = (*flags_p & SF_NOCOMPRESS_MODE) ?
 			load_image(&handle, &snapshot, header->pages - 1) :
 			load_image_lzo(&handle, &snapshot, header->pages - 1);
 	}
 	swap_reader_finish(&handle);
 end:
 	if (!error)
 		pr_debug("PM: Image successfully loaded\n");
 	else
 		pr_debug("PM: Error %d resuming\n", error);
 	return error;
 }
 /**
  *      swsusp_check - Check for swsusp signature in the resume device
  */
 int swsusp_check(void)
 {
 	int error;
 	hib_resume_bdev = blkdev_get_by_dev(swsusp_resume_device,
 					    FMODE_READ, NULL);
 	if (!IS_ERR(hib_resume_bdev)) {
 		set_blocksize(hib_resume_bdev, PAGE_SIZE);
 		clear_page(swsusp_header);
 		error = hib_bio_read_page(swsusp_resume_block,
 					swsusp_header, NULL);
 		if (error)
 			goto put;
 		if (!memcmp(HIBERNATE_SIG, swsusp_header->sig, 10)) {
 			memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
 			/* Reset swap signature now */
 			error = hib_bio_write_page(swsusp_resume_block,
 						swsusp_header, NULL);
 		} else {
 			error = -EINVAL;
 		}
 put:
 		if (error)
 			blkdev_put(hib_resume_bdev, FMODE_READ);
 		else
 			pr_debug("PM: Image signature found, resuming\n");
 	} else {
 		error = PTR_ERR(hib_resume_bdev);
 	}
 	if (error)
 		pr_debug("PM: Image not found (code %d)\n", error);
 	return error;
 }
 /**
  *	swsusp_close - close swap device.
  */
 void swsusp_close(fmode_t mode)
 {
 	if (IS_ERR(hib_resume_bdev)) {
 		pr_debug("PM: Image device not initialised\n");
 		return;
 	}
 	blkdev_put(hib_resume_bdev, mode);
 }
 static int swsusp_header_init(void)
 {
 	swsusp_header = (struct swsusp_header*) __get_free_page(GFP_KERNEL);
 	if (!swsusp_header)
 		panic("Could not allocate memory for swsusp_header\n");
 	return 0;
 }
 core_initcall(swsusp_header_init);