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 } 153