Root/kernel/power/main.c

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
21DEFINE_MUTEX(pm_mutex);
22
23#ifdef CONFIG_PM_SLEEP
24
25/* Routines for PM-transition notifications */
26
27static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
28
29int register_pm_notifier(struct notifier_block *nb)
30{
31    return blocking_notifier_chain_register(&pm_chain_head, nb);
32}
33EXPORT_SYMBOL_GPL(register_pm_notifier);
34
35int unregister_pm_notifier(struct notifier_block *nb)
36{
37    return blocking_notifier_chain_unregister(&pm_chain_head, nb);
38}
39EXPORT_SYMBOL_GPL(unregister_pm_notifier);
40
41int pm_notifier_call_chain(unsigned long val)
42{
43    int ret = blocking_notifier_call_chain(&pm_chain_head, val, NULL);
44
45    return notifier_to_errno(ret);
46}
47
48/* If set, devices may be suspended and resumed asynchronously. */
49int pm_async_enabled = 1;
50
51static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
52                 char *buf)
53{
54    return sprintf(buf, "%d\n", pm_async_enabled);
55}
56
57static 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    if (strict_strtoul(buf, 10, &val))
63        return -EINVAL;
64
65    if (val > 1)
66        return -EINVAL;
67
68    pm_async_enabled = val;
69    return n;
70}
71
72power_attr(pm_async);
73
74#ifdef CONFIG_PM_DEBUG
75int pm_test_level = TEST_NONE;
76
77static 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
86static 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
107static 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
134power_attr(pm_test);
135#endif /* CONFIG_PM_DEBUG */
136
137#ifdef CONFIG_DEBUG_FS
138static 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
158static int suspend_stats_show(struct seq_file *s, void *unused)
159{
160    int i, index, last_dev, last_errno, last_step;
161
162    last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
163    last_dev %= REC_FAILED_NUM;
164    last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
165    last_errno %= REC_FAILED_NUM;
166    last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
167    last_step %= REC_FAILED_NUM;
168    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    seq_printf(s, "failures:\n last_failed_dev:\t%-s\n",
185            suspend_stats.failed_devs[last_dev]);
186    for (i = 1; i < REC_FAILED_NUM; i++) {
187        index = last_dev + REC_FAILED_NUM - i;
188        index %= REC_FAILED_NUM;
189        seq_printf(s, "\t\t\t%-s\n",
190            suspend_stats.failed_devs[index]);
191    }
192    seq_printf(s, " last_failed_errno:\t%-d\n",
193            suspend_stats.errno[last_errno]);
194    for (i = 1; i < REC_FAILED_NUM; i++) {
195        index = last_errno + REC_FAILED_NUM - i;
196        index %= REC_FAILED_NUM;
197        seq_printf(s, "\t\t\t%-d\n",
198            suspend_stats.errno[index]);
199    }
200    seq_printf(s, " last_failed_step:\t%-s\n",
201            suspend_step_name(
202                suspend_stats.failed_steps[last_step]));
203    for (i = 1; i < REC_FAILED_NUM; i++) {
204        index = last_step + REC_FAILED_NUM - i;
205        index %= REC_FAILED_NUM;
206        seq_printf(s, "\t\t\t%-s\n",
207            suspend_step_name(
208                suspend_stats.failed_steps[index]));
209    }
210
211    return 0;
212}
213
214static int suspend_stats_open(struct inode *inode, struct file *file)
215{
216    return single_open(file, suspend_stats_show, NULL);
217}
218
219static 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
226static int __init pm_debugfs_init(void)
227{
228    debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
229            NULL, NULL, &suspend_stats_operations);
230    return 0;
231}
232
233late_initcall(pm_debugfs_init);
234#endif /* CONFIG_DEBUG_FS */
235
236#endif /* CONFIG_PM_SLEEP */
237
238struct kobject *power_kobj;
239
240/**
241 * state - control system power state.
242 *
243 * show() returns what states are supported, which is hard-coded to
244 * 'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
245 * 'disk' (Suspend-to-Disk).
246 *
247 * store() accepts one of those strings, translates it into the
248 * proper enumerated value, and initiates a suspend transition.
249 */
250static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
251              char *buf)
252{
253    char *s = buf;
254#ifdef CONFIG_SUSPEND
255    int i;
256
257    for (i = 0; i < PM_SUSPEND_MAX; i++) {
258        if (pm_states[i] && valid_state(i))
259            s += sprintf(s,"%s ", pm_states[i]);
260    }
261#endif
262#ifdef CONFIG_HIBERNATION
263    s += sprintf(s, "%s\n", "disk");
264#else
265    if (s != buf)
266        /* convert the last space to a newline */
267        *(s-1) = '\n';
268#endif
269    return (s - buf);
270}
271
272static suspend_state_t decode_state(const char *buf, size_t n)
273{
274#ifdef CONFIG_SUSPEND
275    suspend_state_t state = PM_SUSPEND_STANDBY;
276    const char * const *s;
277#endif
278    char *p;
279    int len;
280
281    p = memchr(buf, '\n', n);
282    len = p ? p - buf : n;
283
284    /* Check hibernation first. */
285    if (len == 4 && !strncmp(buf, "disk", len))
286        return PM_SUSPEND_MAX;
287
288#ifdef CONFIG_SUSPEND
289    for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++)
290        if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
291            return state;
292#endif
293
294    return PM_SUSPEND_ON;
295}
296
297static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
298               const char *buf, size_t n)
299{
300    suspend_state_t state;
301    int error;
302
303    error = pm_autosleep_lock();
304    if (error)
305        return error;
306
307    if (pm_autosleep_state() > PM_SUSPEND_ON) {
308        error = -EBUSY;
309        goto out;
310    }
311
312    state = decode_state(buf, n);
313    if (state < PM_SUSPEND_MAX)
314        error = pm_suspend(state);
315    else if (state == PM_SUSPEND_MAX)
316        error = hibernate();
317    else
318        error = -EINVAL;
319
320 out:
321    pm_autosleep_unlock();
322    return error ? error : n;
323}
324
325power_attr(state);
326
327#ifdef CONFIG_PM_SLEEP
328/*
329 * The 'wakeup_count' attribute, along with the functions defined in
330 * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
331 * handled in a non-racy way.
332 *
333 * If a wakeup event occurs when the system is in a sleep state, it simply is
334 * woken up. In turn, if an event that would wake the system up from a sleep
335 * state occurs when it is undergoing a transition to that sleep state, the
336 * transition should be aborted. Moreover, if such an event occurs when the
337 * system is in the working state, an attempt to start a transition to the
338 * given sleep state should fail during certain period after the detection of
339 * the event. Using the 'state' attribute alone is not sufficient to satisfy
340 * these requirements, because a wakeup event may occur exactly when 'state'
341 * is being written to and may be delivered to user space right before it is
342 * frozen, so the event will remain only partially processed until the system is
343 * woken up by another event. In particular, it won't cause the transition to
344 * a sleep state to be aborted.
345 *
346 * This difficulty may be overcome if user space uses 'wakeup_count' before
347 * writing to 'state'. It first should read from 'wakeup_count' and store
348 * the read value. Then, after carrying out its own preparations for the system
349 * transition to a sleep state, it should write the stored value to
350 * 'wakeup_count'. If that fails, at least one wakeup event has occurred since
351 * 'wakeup_count' was read and 'state' should not be written to. Otherwise, it
352 * is allowed to write to 'state', but the transition will be aborted if there
353 * are any wakeup events detected after 'wakeup_count' was written to.
354 */
355
356static ssize_t wakeup_count_show(struct kobject *kobj,
357                struct kobj_attribute *attr,
358                char *buf)
359{
360    unsigned int val;
361
362    return pm_get_wakeup_count(&val, true) ?
363        sprintf(buf, "%u\n", val) : -EINTR;
364}
365
366static ssize_t wakeup_count_store(struct kobject *kobj,
367                struct kobj_attribute *attr,
368                const char *buf, size_t n)
369{
370    unsigned int val;
371    int error;
372
373    error = pm_autosleep_lock();
374    if (error)
375        return error;
376
377    if (pm_autosleep_state() > PM_SUSPEND_ON) {
378        error = -EBUSY;
379        goto out;
380    }
381
382    error = -EINVAL;
383    if (sscanf(buf, "%u", &val) == 1) {
384        if (pm_save_wakeup_count(val))
385            error = n;
386    }
387
388 out:
389    pm_autosleep_unlock();
390    return error;
391}
392
393power_attr(wakeup_count);
394
395#ifdef CONFIG_PM_AUTOSLEEP
396static ssize_t autosleep_show(struct kobject *kobj,
397                  struct kobj_attribute *attr,
398                  char *buf)
399{
400    suspend_state_t state = pm_autosleep_state();
401
402    if (state == PM_SUSPEND_ON)
403        return sprintf(buf, "off\n");
404
405#ifdef CONFIG_SUSPEND
406    if (state < PM_SUSPEND_MAX)
407        return sprintf(buf, "%s\n", valid_state(state) ?
408                        pm_states[state] : "error");
409#endif
410#ifdef CONFIG_HIBERNATION
411    return sprintf(buf, "disk\n");
412#else
413    return sprintf(buf, "error");
414#endif
415}
416
417static ssize_t autosleep_store(struct kobject *kobj,
418                   struct kobj_attribute *attr,
419                   const char *buf, size_t n)
420{
421    suspend_state_t state = decode_state(buf, n);
422    int error;
423
424    if (state == PM_SUSPEND_ON
425        && strcmp(buf, "off") && strcmp(buf, "off\n"))
426        return -EINVAL;
427
428    error = pm_autosleep_set_state(state);
429    return error ? error : n;
430}
431
432power_attr(autosleep);
433#endif /* CONFIG_PM_AUTOSLEEP */
434
435#ifdef CONFIG_PM_WAKELOCKS
436static ssize_t wake_lock_show(struct kobject *kobj,
437                  struct kobj_attribute *attr,
438                  char *buf)
439{
440    return pm_show_wakelocks(buf, true);
441}
442
443static ssize_t wake_lock_store(struct kobject *kobj,
444                   struct kobj_attribute *attr,
445                   const char *buf, size_t n)
446{
447    int error = pm_wake_lock(buf);
448    return error ? error : n;
449}
450
451power_attr(wake_lock);
452
453static ssize_t wake_unlock_show(struct kobject *kobj,
454                struct kobj_attribute *attr,
455                char *buf)
456{
457    return pm_show_wakelocks(buf, false);
458}
459
460static ssize_t wake_unlock_store(struct kobject *kobj,
461                 struct kobj_attribute *attr,
462                 const char *buf, size_t n)
463{
464    int error = pm_wake_unlock(buf);
465    return error ? error : n;
466}
467
468power_attr(wake_unlock);
469
470#endif /* CONFIG_PM_WAKELOCKS */
471#endif /* CONFIG_PM_SLEEP */
472
473#ifdef CONFIG_PM_TRACE
474int pm_trace_enabled;
475
476static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
477                 char *buf)
478{
479    return sprintf(buf, "%d\n", pm_trace_enabled);
480}
481
482static ssize_t
483pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
484           const char *buf, size_t n)
485{
486    int val;
487
488    if (sscanf(buf, "%d", &val) == 1) {
489        pm_trace_enabled = !!val;
490        return n;
491    }
492    return -EINVAL;
493}
494
495power_attr(pm_trace);
496
497static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
498                       struct kobj_attribute *attr,
499                       char *buf)
500{
501    return show_trace_dev_match(buf, PAGE_SIZE);
502}
503
504static ssize_t
505pm_trace_dev_match_store(struct kobject *kobj, struct kobj_attribute *attr,
506             const char *buf, size_t n)
507{
508    return -EINVAL;
509}
510
511power_attr(pm_trace_dev_match);
512
513#endif /* CONFIG_PM_TRACE */
514
515static struct attribute * g[] = {
516    &state_attr.attr,
517#ifdef CONFIG_PM_TRACE
518    &pm_trace_attr.attr,
519    &pm_trace_dev_match_attr.attr,
520#endif
521#ifdef CONFIG_PM_SLEEP
522    &pm_async_attr.attr,
523    &wakeup_count_attr.attr,
524#ifdef CONFIG_PM_AUTOSLEEP
525    &autosleep_attr.attr,
526#endif
527#ifdef CONFIG_PM_WAKELOCKS
528    &wake_lock_attr.attr,
529    &wake_unlock_attr.attr,
530#endif
531#ifdef CONFIG_PM_DEBUG
532    &pm_test_attr.attr,
533#endif
534#endif
535    NULL,
536};
537
538static struct attribute_group attr_group = {
539    .attrs = g,
540};
541
542#ifdef CONFIG_PM_RUNTIME
543struct workqueue_struct *pm_wq;
544EXPORT_SYMBOL_GPL(pm_wq);
545
546static int __init pm_start_workqueue(void)
547{
548    pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
549
550    return pm_wq ? 0 : -ENOMEM;
551}
552#else
553static inline int pm_start_workqueue(void) { return 0; }
554#endif
555
556static int __init pm_init(void)
557{
558    int error = pm_start_workqueue();
559    if (error)
560        return error;
561    hibernate_image_size_init();
562    hibernate_reserved_size_init();
563    power_kobj = kobject_create_and_add("power", NULL);
564    if (!power_kobj)
565        return -ENOMEM;
566    error = sysfs_create_group(power_kobj, &attr_group);
567    if (error)
568        return error;
569    return pm_autosleep_init();
570}
571
572core_initcall(pm_init);
573

Archive Download this file



interactive