Branch data Line data Source code
1 : : /*
2 : : * kernel/power/main.c - PM subsystem core functionality.
3 : : *
4 : : * Copyright (c) 2003 Patrick Mochel
5 : : * Copyright (c) 2003 Open Source Development Lab
6 : : *
7 : : * This file is released under the GPLv2
8 : : *
9 : : */
10 : :
11 : : #include <linux/export.h>
12 : : #include <linux/kobject.h>
13 : : #include <linux/string.h>
14 : : #include <linux/resume-trace.h>
15 : : #include <linux/workqueue.h>
16 : : #include <linux/debugfs.h>
17 : : #include <linux/seq_file.h>
18 : :
19 : : #include "power.h"
20 : :
21 : : DEFINE_MUTEX(pm_mutex);
22 : :
23 : : #ifdef CONFIG_PM_SLEEP
24 : :
25 : : /* Routines for PM-transition notifications */
26 : :
27 : : static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
28 : :
29 : 0 : int register_pm_notifier(struct notifier_block *nb)
30 : : {
31 : 0 : return blocking_notifier_chain_register(&pm_chain_head, nb);
32 : : }
33 : : EXPORT_SYMBOL_GPL(register_pm_notifier);
34 : :
35 : 0 : int unregister_pm_notifier(struct notifier_block *nb)
36 : : {
37 : 0 : return blocking_notifier_chain_unregister(&pm_chain_head, nb);
38 : : }
39 : : EXPORT_SYMBOL_GPL(unregister_pm_notifier);
40 : :
41 : 0 : int pm_notifier_call_chain(unsigned long val)
42 : : {
43 : 0 : int ret = blocking_notifier_call_chain(&pm_chain_head, val, NULL);
44 : :
45 : 0 : return notifier_to_errno(ret);
46 : : }
47 : :
48 : : /* If set, devices may be suspended and resumed asynchronously. */
49 : : int pm_async_enabled = 1;
50 : :
51 : 0 : static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
52 : : char *buf)
53 : : {
54 : 0 : return sprintf(buf, "%d\n", pm_async_enabled);
55 : : }
56 : :
57 : 0 : static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
58 : : const char *buf, size_t n)
59 : : {
60 : : unsigned long val;
61 : :
62 [ # # ]: 0 : if (kstrtoul(buf, 10, &val))
63 : : return -EINVAL;
64 : :
65 [ # # ]: 0 : if (val > 1)
66 : : return -EINVAL;
67 : :
68 : 0 : pm_async_enabled = val;
69 : 0 : return n;
70 : : }
71 : :
72 : : power_attr(pm_async);
73 : :
74 : : #ifdef CONFIG_PM_DEBUG
75 : : int pm_test_level = TEST_NONE;
76 : :
77 : : static const char * const pm_tests[__TEST_AFTER_LAST] = {
78 : : [TEST_NONE] = "none",
79 : : [TEST_CORE] = "core",
80 : : [TEST_CPUS] = "processors",
81 : : [TEST_PLATFORM] = "platform",
82 : : [TEST_DEVICES] = "devices",
83 : : [TEST_FREEZER] = "freezer",
84 : : };
85 : :
86 : : static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
87 : : char *buf)
88 : : {
89 : : char *s = buf;
90 : : int level;
91 : :
92 : : for (level = TEST_FIRST; level <= TEST_MAX; level++)
93 : : if (pm_tests[level]) {
94 : : if (level == pm_test_level)
95 : : s += sprintf(s, "[%s] ", pm_tests[level]);
96 : : else
97 : : s += sprintf(s, "%s ", pm_tests[level]);
98 : : }
99 : :
100 : : if (s != buf)
101 : : /* convert the last space to a newline */
102 : : *(s-1) = '\n';
103 : :
104 : : return (s - buf);
105 : : }
106 : :
107 : : static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
108 : : const char *buf, size_t n)
109 : : {
110 : : const char * const *s;
111 : : int level;
112 : : char *p;
113 : : int len;
114 : : int error = -EINVAL;
115 : :
116 : : p = memchr(buf, '\n', n);
117 : : len = p ? p - buf : n;
118 : :
119 : : lock_system_sleep();
120 : :
121 : : level = TEST_FIRST;
122 : : for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
123 : : if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
124 : : pm_test_level = level;
125 : : error = 0;
126 : : break;
127 : : }
128 : :
129 : : unlock_system_sleep();
130 : :
131 : : return error ? error : n;
132 : : }
133 : :
134 : : power_attr(pm_test);
135 : : #endif /* CONFIG_PM_DEBUG */
136 : :
137 : : #ifdef CONFIG_DEBUG_FS
138 : : static char *suspend_step_name(enum suspend_stat_step step)
139 : : {
140 : : switch (step) {
141 : : case SUSPEND_FREEZE:
142 : : return "freeze";
143 : : case SUSPEND_PREPARE:
144 : : return "prepare";
145 : : case SUSPEND_SUSPEND:
146 : : return "suspend";
147 : : case SUSPEND_SUSPEND_NOIRQ:
148 : : return "suspend_noirq";
149 : : case SUSPEND_RESUME_NOIRQ:
150 : : return "resume_noirq";
151 : : case SUSPEND_RESUME:
152 : : return "resume";
153 : : default:
154 : : return "";
155 : : }
156 : : }
157 : :
158 : 0 : static int suspend_stats_show(struct seq_file *s, void *unused)
159 : : {
160 : : int i, index, last_dev, last_errno, last_step;
161 : :
162 : 0 : last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
163 : 0 : last_dev %= REC_FAILED_NUM;
164 : 0 : last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
165 : 0 : last_errno %= REC_FAILED_NUM;
166 : 0 : last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
167 : 0 : last_step %= REC_FAILED_NUM;
168 : 0 : seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n"
169 : : "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n",
170 : : "success", suspend_stats.success,
171 : : "fail", suspend_stats.fail,
172 : : "failed_freeze", suspend_stats.failed_freeze,
173 : : "failed_prepare", suspend_stats.failed_prepare,
174 : : "failed_suspend", suspend_stats.failed_suspend,
175 : : "failed_suspend_late",
176 : : suspend_stats.failed_suspend_late,
177 : : "failed_suspend_noirq",
178 : : suspend_stats.failed_suspend_noirq,
179 : : "failed_resume", suspend_stats.failed_resume,
180 : : "failed_resume_early",
181 : : suspend_stats.failed_resume_early,
182 : : "failed_resume_noirq",
183 : : suspend_stats.failed_resume_noirq);
184 : 0 : seq_printf(s, "failures:\n last_failed_dev:\t%-s\n",
185 : 0 : suspend_stats.failed_devs[last_dev]);
186 [ # # ]: 0 : for (i = 1; i < REC_FAILED_NUM; i++) {
187 : 0 : index = last_dev + REC_FAILED_NUM - i;
188 : 0 : index %= REC_FAILED_NUM;
189 : 0 : seq_printf(s, "\t\t\t%-s\n",
190 : 0 : suspend_stats.failed_devs[index]);
191 : : }
192 : 0 : seq_printf(s, " last_failed_errno:\t%-d\n",
193 : : suspend_stats.errno[last_errno]);
194 [ # # ]: 0 : for (i = 1; i < REC_FAILED_NUM; i++) {
195 : 0 : index = last_errno + REC_FAILED_NUM - i;
196 : 0 : index %= REC_FAILED_NUM;
197 : 0 : seq_printf(s, "\t\t\t%-d\n",
198 : : suspend_stats.errno[index]);
199 : : }
200 [ # # ]: 0 : seq_printf(s, " last_failed_step:\t%-s\n",
201 : : suspend_step_name(
202 : : suspend_stats.failed_steps[last_step]));
203 [ # # ]: 0 : for (i = 1; i < REC_FAILED_NUM; i++) {
204 : 0 : index = last_step + REC_FAILED_NUM - i;
205 : 0 : index %= REC_FAILED_NUM;
206 [ # # ]: 0 : seq_printf(s, "\t\t\t%-s\n",
207 : : suspend_step_name(
208 : : suspend_stats.failed_steps[index]));
209 : : }
210 : :
211 : 0 : return 0;
212 : : }
213 : :
214 : 0 : static int suspend_stats_open(struct inode *inode, struct file *file)
215 : : {
216 : 0 : return single_open(file, suspend_stats_show, NULL);
217 : : }
218 : :
219 : : static const struct file_operations suspend_stats_operations = {
220 : : .open = suspend_stats_open,
221 : : .read = seq_read,
222 : : .llseek = seq_lseek,
223 : : .release = single_release,
224 : : };
225 : :
226 : 0 : static int __init pm_debugfs_init(void)
227 : : {
228 : 0 : debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
229 : : NULL, NULL, &suspend_stats_operations);
230 : 0 : return 0;
231 : : }
232 : :
233 : : late_initcall(pm_debugfs_init);
234 : : #endif /* CONFIG_DEBUG_FS */
235 : :
236 : : #endif /* CONFIG_PM_SLEEP */
237 : :
238 : : #ifdef CONFIG_PM_SLEEP_DEBUG
239 : : /*
240 : : * pm_print_times: print time taken by devices to suspend and resume.
241 : : *
242 : : * show() returns whether printing of suspend and resume times is enabled.
243 : : * store() accepts 0 or 1. 0 disables printing and 1 enables it.
244 : : */
245 : : bool pm_print_times_enabled;
246 : :
247 : : static ssize_t pm_print_times_show(struct kobject *kobj,
248 : : struct kobj_attribute *attr, char *buf)
249 : : {
250 : : return sprintf(buf, "%d\n", pm_print_times_enabled);
251 : : }
252 : :
253 : : static ssize_t pm_print_times_store(struct kobject *kobj,
254 : : struct kobj_attribute *attr,
255 : : const char *buf, size_t n)
256 : : {
257 : : unsigned long val;
258 : :
259 : : if (kstrtoul(buf, 10, &val))
260 : : return -EINVAL;
261 : :
262 : : if (val > 1)
263 : : return -EINVAL;
264 : :
265 : : pm_print_times_enabled = !!val;
266 : : return n;
267 : : }
268 : :
269 : : power_attr(pm_print_times);
270 : :
271 : : static inline void pm_print_times_init(void)
272 : : {
273 : : pm_print_times_enabled = !!initcall_debug;
274 : : }
275 : : #else /* !CONFIG_PP_SLEEP_DEBUG */
276 : : static inline void pm_print_times_init(void) {}
277 : : #endif /* CONFIG_PM_SLEEP_DEBUG */
278 : :
279 : : struct kobject *power_kobj;
280 : :
281 : : /**
282 : : * state - control system power state.
283 : : *
284 : : * show() returns what states are supported, which is hard-coded to
285 : : * 'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
286 : : * 'disk' (Suspend-to-Disk).
287 : : *
288 : : * store() accepts one of those strings, translates it into the
289 : : * proper enumerated value, and initiates a suspend transition.
290 : : */
291 : 0 : static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
292 : : char *buf)
293 : : {
294 : : char *s = buf;
295 : : #ifdef CONFIG_SUSPEND
296 : : int i;
297 : :
298 [ # # ]: 0 : for (i = 0; i < PM_SUSPEND_MAX; i++) {
299 [ # # ][ # # ]: 0 : if (pm_states[i] && valid_state(i))
300 : 0 : s += sprintf(s,"%s ", pm_states[i]);
301 : : }
302 : : #endif
303 : : #ifdef CONFIG_HIBERNATION
304 : : s += sprintf(s, "%s\n", "disk");
305 : : #else
306 [ # # ]: 0 : if (s != buf)
307 : : /* convert the last space to a newline */
308 : 0 : *(s-1) = '\n';
309 : : #endif
310 : 0 : return (s - buf);
311 : : }
312 : :
313 : 0 : static suspend_state_t decode_state(const char *buf, size_t n)
314 : : {
315 : : #ifdef CONFIG_SUSPEND
316 : : suspend_state_t state = PM_SUSPEND_MIN;
317 : : const char * const *s;
318 : : #endif
319 : : char *p;
320 : : int len;
321 : :
322 : 0 : p = memchr(buf, '\n', n);
323 [ # # ]: 0 : len = p ? p - buf : n;
324 : :
325 : : /* Check hibernation first. */
326 [ # # ][ # # ]: 0 : if (len == 4 && !strncmp(buf, "disk", len))
327 : : return PM_SUSPEND_MAX;
328 : :
329 : : #ifdef CONFIG_SUSPEND
330 [ # # ]: 0 : for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++)
331 [ # # ][ # # ]: 0 : if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
[ # # ]
332 : : return state;
333 : : #endif
334 : :
335 : : return PM_SUSPEND_ON;
336 : : }
337 : :
338 : 0 : static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
339 : : const char *buf, size_t n)
340 : : {
341 : : suspend_state_t state;
342 : : int error;
343 : :
344 : : error = pm_autosleep_lock();
345 : : if (error)
346 : : return error;
347 : :
348 : : if (pm_autosleep_state() > PM_SUSPEND_ON) {
349 : : error = -EBUSY;
350 : : goto out;
351 : : }
352 : :
353 : 0 : state = decode_state(buf, n);
354 [ # # ]: 0 : if (state < PM_SUSPEND_MAX)
355 : 0 : error = pm_suspend(state);
356 [ # # ]: 0 : else if (state == PM_SUSPEND_MAX)
357 : : error = hibernate();
358 : : else
359 : : error = -EINVAL;
360 : :
361 : : out:
362 : : pm_autosleep_unlock();
363 [ # # ]: 0 : return error ? error : n;
364 : : }
365 : :
366 : : power_attr(state);
367 : :
368 : : #ifdef CONFIG_PM_SLEEP
369 : : /*
370 : : * The 'wakeup_count' attribute, along with the functions defined in
371 : : * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
372 : : * handled in a non-racy way.
373 : : *
374 : : * If a wakeup event occurs when the system is in a sleep state, it simply is
375 : : * woken up. In turn, if an event that would wake the system up from a sleep
376 : : * state occurs when it is undergoing a transition to that sleep state, the
377 : : * transition should be aborted. Moreover, if such an event occurs when the
378 : : * system is in the working state, an attempt to start a transition to the
379 : : * given sleep state should fail during certain period after the detection of
380 : : * the event. Using the 'state' attribute alone is not sufficient to satisfy
381 : : * these requirements, because a wakeup event may occur exactly when 'state'
382 : : * is being written to and may be delivered to user space right before it is
383 : : * frozen, so the event will remain only partially processed until the system is
384 : : * woken up by another event. In particular, it won't cause the transition to
385 : : * a sleep state to be aborted.
386 : : *
387 : : * This difficulty may be overcome if user space uses 'wakeup_count' before
388 : : * writing to 'state'. It first should read from 'wakeup_count' and store
389 : : * the read value. Then, after carrying out its own preparations for the system
390 : : * transition to a sleep state, it should write the stored value to
391 : : * 'wakeup_count'. If that fails, at least one wakeup event has occurred since
392 : : * 'wakeup_count' was read and 'state' should not be written to. Otherwise, it
393 : : * is allowed to write to 'state', but the transition will be aborted if there
394 : : * are any wakeup events detected after 'wakeup_count' was written to.
395 : : */
396 : :
397 : 0 : static ssize_t wakeup_count_show(struct kobject *kobj,
398 : : struct kobj_attribute *attr,
399 : : char *buf)
400 : : {
401 : : unsigned int val;
402 : :
403 : 0 : return pm_get_wakeup_count(&val, true) ?
404 [ # # ]: 0 : sprintf(buf, "%u\n", val) : -EINTR;
405 : : }
406 : :
407 : 0 : static ssize_t wakeup_count_store(struct kobject *kobj,
408 : : struct kobj_attribute *attr,
409 : : const char *buf, size_t n)
410 : : {
411 : : unsigned int val;
412 : : int error;
413 : :
414 : : error = pm_autosleep_lock();
415 : : if (error)
416 : : return error;
417 : :
418 : : if (pm_autosleep_state() > PM_SUSPEND_ON) {
419 : : error = -EBUSY;
420 : : goto out;
421 : : }
422 : :
423 : : error = -EINVAL;
424 [ # # ]: 0 : if (sscanf(buf, "%u", &val) == 1) {
425 [ # # ]: 0 : if (pm_save_wakeup_count(val))
426 : 0 : error = n;
427 : : else
428 : 0 : pm_print_active_wakeup_sources();
429 : : }
430 : :
431 : : out:
432 : : pm_autosleep_unlock();
433 : : return error;
434 : : }
435 : :
436 : : power_attr(wakeup_count);
437 : :
438 : : #ifdef CONFIG_PM_AUTOSLEEP
439 : : static ssize_t autosleep_show(struct kobject *kobj,
440 : : struct kobj_attribute *attr,
441 : : char *buf)
442 : : {
443 : : suspend_state_t state = pm_autosleep_state();
444 : :
445 : : if (state == PM_SUSPEND_ON)
446 : : return sprintf(buf, "off\n");
447 : :
448 : : #ifdef CONFIG_SUSPEND
449 : : if (state < PM_SUSPEND_MAX)
450 : : return sprintf(buf, "%s\n", valid_state(state) ?
451 : : pm_states[state] : "error");
452 : : #endif
453 : : #ifdef CONFIG_HIBERNATION
454 : : return sprintf(buf, "disk\n");
455 : : #else
456 : : return sprintf(buf, "error");
457 : : #endif
458 : : }
459 : :
460 : : static ssize_t autosleep_store(struct kobject *kobj,
461 : : struct kobj_attribute *attr,
462 : : const char *buf, size_t n)
463 : : {
464 : : suspend_state_t state = decode_state(buf, n);
465 : : int error;
466 : :
467 : : if (state == PM_SUSPEND_ON
468 : : && strcmp(buf, "off") && strcmp(buf, "off\n"))
469 : : return -EINVAL;
470 : :
471 : : error = pm_autosleep_set_state(state);
472 : : return error ? error : n;
473 : : }
474 : :
475 : : power_attr(autosleep);
476 : : #endif /* CONFIG_PM_AUTOSLEEP */
477 : :
478 : : #ifdef CONFIG_PM_WAKELOCKS
479 : : static ssize_t wake_lock_show(struct kobject *kobj,
480 : : struct kobj_attribute *attr,
481 : : char *buf)
482 : : {
483 : : return pm_show_wakelocks(buf, true);
484 : : }
485 : :
486 : : static ssize_t wake_lock_store(struct kobject *kobj,
487 : : struct kobj_attribute *attr,
488 : : const char *buf, size_t n)
489 : : {
490 : : int error = pm_wake_lock(buf);
491 : : return error ? error : n;
492 : : }
493 : :
494 : : power_attr(wake_lock);
495 : :
496 : : static ssize_t wake_unlock_show(struct kobject *kobj,
497 : : struct kobj_attribute *attr,
498 : : char *buf)
499 : : {
500 : : return pm_show_wakelocks(buf, false);
501 : : }
502 : :
503 : : static ssize_t wake_unlock_store(struct kobject *kobj,
504 : : struct kobj_attribute *attr,
505 : : const char *buf, size_t n)
506 : : {
507 : : int error = pm_wake_unlock(buf);
508 : : return error ? error : n;
509 : : }
510 : :
511 : : power_attr(wake_unlock);
512 : :
513 : : #endif /* CONFIG_PM_WAKELOCKS */
514 : : #endif /* CONFIG_PM_SLEEP */
515 : :
516 : : #ifdef CONFIG_PM_TRACE
517 : : int pm_trace_enabled;
518 : :
519 : : static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
520 : : char *buf)
521 : : {
522 : : return sprintf(buf, "%d\n", pm_trace_enabled);
523 : : }
524 : :
525 : : static ssize_t
526 : : pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
527 : : const char *buf, size_t n)
528 : : {
529 : : int val;
530 : :
531 : : if (sscanf(buf, "%d", &val) == 1) {
532 : : pm_trace_enabled = !!val;
533 : : if (pm_trace_enabled) {
534 : : pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
535 : : "PM: Correct system time has to be restored manually after resume.\n");
536 : : }
537 : : return n;
538 : : }
539 : : return -EINVAL;
540 : : }
541 : :
542 : : power_attr(pm_trace);
543 : :
544 : : static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
545 : : struct kobj_attribute *attr,
546 : : char *buf)
547 : : {
548 : : return show_trace_dev_match(buf, PAGE_SIZE);
549 : : }
550 : :
551 : : static ssize_t
552 : : pm_trace_dev_match_store(struct kobject *kobj, struct kobj_attribute *attr,
553 : : const char *buf, size_t n)
554 : : {
555 : : return -EINVAL;
556 : : }
557 : :
558 : : power_attr(pm_trace_dev_match);
559 : :
560 : : #endif /* CONFIG_PM_TRACE */
561 : :
562 : : #ifdef CONFIG_FREEZER
563 : 0 : static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
564 : : struct kobj_attribute *attr, char *buf)
565 : : {
566 : 0 : return sprintf(buf, "%u\n", freeze_timeout_msecs);
567 : : }
568 : :
569 : 0 : static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
570 : : struct kobj_attribute *attr,
571 : : const char *buf, size_t n)
572 : : {
573 : : unsigned long val;
574 : :
575 [ # # ]: 0 : if (kstrtoul(buf, 10, &val))
576 : : return -EINVAL;
577 : :
578 : 0 : freeze_timeout_msecs = val;
579 : 0 : return n;
580 : : }
581 : :
582 : : power_attr(pm_freeze_timeout);
583 : :
584 : : #endif /* CONFIG_FREEZER*/
585 : :
586 : : static struct attribute * g[] = {
587 : : &state_attr.attr,
588 : : #ifdef CONFIG_PM_TRACE
589 : : &pm_trace_attr.attr,
590 : : &pm_trace_dev_match_attr.attr,
591 : : #endif
592 : : #ifdef CONFIG_PM_SLEEP
593 : : &pm_async_attr.attr,
594 : : &wakeup_count_attr.attr,
595 : : #ifdef CONFIG_PM_AUTOSLEEP
596 : : &autosleep_attr.attr,
597 : : #endif
598 : : #ifdef CONFIG_PM_WAKELOCKS
599 : : &wake_lock_attr.attr,
600 : : &wake_unlock_attr.attr,
601 : : #endif
602 : : #ifdef CONFIG_PM_DEBUG
603 : : &pm_test_attr.attr,
604 : : #endif
605 : : #ifdef CONFIG_PM_SLEEP_DEBUG
606 : : &pm_print_times_attr.attr,
607 : : #endif
608 : : #endif
609 : : #ifdef CONFIG_FREEZER
610 : : &pm_freeze_timeout_attr.attr,
611 : : #endif
612 : : NULL,
613 : : };
614 : :
615 : : static struct attribute_group attr_group = {
616 : : .attrs = g,
617 : : };
618 : :
619 : : #ifdef CONFIG_PM_RUNTIME
620 : : struct workqueue_struct *pm_wq;
621 : : EXPORT_SYMBOL_GPL(pm_wq);
622 : :
623 : : static int __init pm_start_workqueue(void)
624 : : {
625 : : pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
626 : :
627 : : return pm_wq ? 0 : -ENOMEM;
628 : : }
629 : : #else
630 : : static inline int pm_start_workqueue(void) { return 0; }
631 : : #endif
632 : :
633 : 0 : static int __init pm_init(void)
634 : : {
635 : : int error = pm_start_workqueue();
636 : : if (error)
637 : : return error;
638 : : hibernate_image_size_init();
639 : : hibernate_reserved_size_init();
640 : 0 : power_kobj = kobject_create_and_add("power", NULL);
641 [ # # ]: 0 : if (!power_kobj)
642 : : return -ENOMEM;
643 : 0 : error = sysfs_create_group(power_kobj, &attr_group);
644 [ # # ]: 0 : if (error)
645 : 0 : return error;
646 : : pm_print_times_init();
647 : : return pm_autosleep_init();
648 : : }
649 : :
650 : : core_initcall(pm_init);
|
