arm64: dts: qcom: sm8550: add TRNG node
[linux-modified.git] / kernel / power / console.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Functions for saving/restoring console.
4  *
5  * Originally from swsusp.
6  */
7
8 #include <linux/console.h>
9 #include <linux/vt_kern.h>
10 #include <linux/kbd_kern.h>
11 #include <linux/vt.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include "power.h"
15
16 #define SUSPEND_CONSOLE (MAX_NR_CONSOLES-1)
17
18 static int orig_fgconsole, orig_kmsg;
19
20 static DEFINE_MUTEX(vt_switch_mutex);
21
22 struct pm_vt_switch {
23         struct list_head head;
24         struct device *dev;
25         bool required;
26 };
27
28 static LIST_HEAD(pm_vt_switch_list);
29
30
31 /**
32  * pm_vt_switch_required - indicate VT switch at suspend requirements
33  * @dev: device
34  * @required: if true, caller needs VT switch at suspend/resume time
35  *
36  * The different console drivers may or may not require VT switches across
37  * suspend/resume, depending on how they handle restoring video state and
38  * what may be running.
39  *
40  * Drivers can indicate support for switchless suspend/resume, which can
41  * save time and flicker, by using this routine and passing 'false' as
42  * the argument.  If any loaded driver needs VT switching, or the
43  * no_console_suspend argument has been passed on the command line, VT
44  * switches will occur.
45  */
46 void pm_vt_switch_required(struct device *dev, bool required)
47 {
48         struct pm_vt_switch *entry, *tmp;
49
50         mutex_lock(&vt_switch_mutex);
51         list_for_each_entry(tmp, &pm_vt_switch_list, head) {
52                 if (tmp->dev == dev) {
53                         /* already registered, update requirement */
54                         tmp->required = required;
55                         goto out;
56                 }
57         }
58
59         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
60         if (!entry)
61                 goto out;
62
63         entry->required = required;
64         entry->dev = dev;
65
66         list_add(&entry->head, &pm_vt_switch_list);
67 out:
68         mutex_unlock(&vt_switch_mutex);
69 }
70 EXPORT_SYMBOL(pm_vt_switch_required);
71
72 /**
73  * pm_vt_switch_unregister - stop tracking a device's VT switching needs
74  * @dev: device
75  *
76  * Remove @dev from the vt switch list.
77  */
78 void pm_vt_switch_unregister(struct device *dev)
79 {
80         struct pm_vt_switch *tmp;
81
82         mutex_lock(&vt_switch_mutex);
83         list_for_each_entry(tmp, &pm_vt_switch_list, head) {
84                 if (tmp->dev == dev) {
85                         list_del(&tmp->head);
86                         kfree(tmp);
87                         break;
88                 }
89         }
90         mutex_unlock(&vt_switch_mutex);
91 }
92 EXPORT_SYMBOL(pm_vt_switch_unregister);
93
94 /*
95  * There are three cases when a VT switch on suspend/resume are required:
96  *   1) no driver has indicated a requirement one way or another, so preserve
97  *      the old behavior
98  *   2) console suspend is disabled, we want to see debug messages across
99  *      suspend/resume
100  *   3) any registered driver indicates it needs a VT switch
101  *
102  * If none of these conditions is present, meaning we have at least one driver
103  * that doesn't need the switch, and none that do, we can avoid it to make
104  * resume look a little prettier (and suspend too, but that's usually hidden,
105  * e.g. when closing the lid on a laptop).
106  */
107 static bool pm_vt_switch(void)
108 {
109         struct pm_vt_switch *entry;
110         bool ret = true;
111
112         mutex_lock(&vt_switch_mutex);
113         if (list_empty(&pm_vt_switch_list))
114                 goto out;
115
116         if (!console_suspend_enabled)
117                 goto out;
118
119         list_for_each_entry(entry, &pm_vt_switch_list, head) {
120                 if (entry->required)
121                         goto out;
122         }
123
124         ret = false;
125 out:
126         mutex_unlock(&vt_switch_mutex);
127         return ret;
128 }
129
130 void pm_prepare_console(void)
131 {
132         if (!pm_vt_switch())
133                 return;
134
135         orig_fgconsole = vt_move_to_console(SUSPEND_CONSOLE, 1);
136         if (orig_fgconsole < 0)
137                 return;
138
139         orig_kmsg = vt_kmsg_redirect(SUSPEND_CONSOLE);
140         return;
141 }
142
143 void pm_restore_console(void)
144 {
145         if (!pm_vt_switch())
146                 return;
147
148         if (orig_fgconsole >= 0) {
149                 vt_move_to_console(orig_fgconsole, 0);
150                 vt_kmsg_redirect(orig_kmsg);
151         }
152 }