1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2010 Brian King IBM Corporation 4 */ 5 6 #include <linux/cpu.h> 7 #include <linux/delay.h> 8 #include <linux/suspend.h> 9 #include <linux/stat.h> 10 #include <asm/firmware.h> 11 #include <asm/hvcall.h> 12 #include <asm/machdep.h> 13 #include <asm/mmu.h> 14 #include <asm/rtas.h> 15 #include <asm/topology.h> 16 #include "pseries.h" 17 18 static struct device suspend_dev; 19 20 /** 21 * pseries_suspend_begin - First phase of hibernation 22 * 23 * Check to ensure we are in a valid state to hibernate 24 * 25 * Return value: 26 * 0 on success / other on failure 27 **/ 28 static int pseries_suspend_begin(u64 stream_id) 29 { 30 long vasi_state, rc; 31 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 32 33 /* Make sure the state is valid */ 34 rc = plpar_hcall(H_VASI_STATE, retbuf, stream_id); 35 36 vasi_state = retbuf[0]; 37 38 if (rc) { 39 pr_err("pseries_suspend_begin: vasi_state returned %ld\n",rc); 40 return rc; 41 } else if (vasi_state == H_VASI_ENABLED) { 42 return -EAGAIN; 43 } else if (vasi_state != H_VASI_SUSPENDING) { 44 pr_err("pseries_suspend_begin: vasi_state returned state %ld\n", 45 vasi_state); 46 return -EIO; 47 } 48 return 0; 49 } 50 51 /** 52 * pseries_suspend_enter - Final phase of hibernation 53 * 54 * Return value: 55 * 0 on success / other on failure 56 **/ 57 static int pseries_suspend_enter(suspend_state_t state) 58 { 59 return rtas_ibm_suspend_me(NULL); 60 } 61 62 /** 63 * store_hibernate - Initiate partition hibernation 64 * @dev: subsys root device 65 * @attr: device attribute struct 66 * @buf: buffer 67 * @count: buffer size 68 * 69 * Write the stream ID received from the HMC to this file 70 * to trigger hibernating the partition 71 * 72 * Return value: 73 * number of bytes printed to buffer / other on failure 74 **/ 75 static ssize_t store_hibernate(struct device *dev, 76 struct device_attribute *attr, 77 const char *buf, size_t count) 78 { 79 u64 stream_id; 80 int rc; 81 82 if (!capable(CAP_SYS_ADMIN)) 83 return -EPERM; 84 85 stream_id = simple_strtoul(buf, NULL, 16); 86 87 do { 88 rc = pseries_suspend_begin(stream_id); 89 if (rc == -EAGAIN) 90 ssleep(1); 91 } while (rc == -EAGAIN); 92 93 if (!rc) 94 rc = pm_suspend(PM_SUSPEND_MEM); 95 96 if (!rc) { 97 rc = count; 98 post_mobility_fixup(); 99 } 100 101 102 return rc; 103 } 104 105 #define USER_DT_UPDATE 0 106 #define KERN_DT_UPDATE 1 107 108 /** 109 * show_hibernate - Report device tree update responsibilty 110 * @dev: subsys root device 111 * @attr: device attribute struct 112 * @buf: buffer 113 * 114 * Report whether a device tree update is performed by the kernel after a 115 * resume, or if drmgr must coordinate the update from user space. 116 * 117 * Return value: 118 * 0 if drmgr is to initiate update, and 1 otherwise 119 **/ 120 static ssize_t show_hibernate(struct device *dev, 121 struct device_attribute *attr, 122 char *buf) 123 { 124 return sprintf(buf, "%d\n", KERN_DT_UPDATE); 125 } 126 127 static DEVICE_ATTR(hibernate, 0644, show_hibernate, store_hibernate); 128 129 static struct bus_type suspend_subsys = { 130 .name = "power", 131 .dev_name = "power", 132 }; 133 134 static const struct platform_suspend_ops pseries_suspend_ops = { 135 .valid = suspend_valid_only_mem, 136 .enter = pseries_suspend_enter, 137 }; 138 139 /** 140 * pseries_suspend_sysfs_register - Register with sysfs 141 * 142 * Return value: 143 * 0 on success / other on failure 144 **/ 145 static int pseries_suspend_sysfs_register(struct device *dev) 146 { 147 struct device *dev_root; 148 int rc; 149 150 if ((rc = subsys_system_register(&suspend_subsys, NULL))) 151 return rc; 152 153 dev->id = 0; 154 dev->bus = &suspend_subsys; 155 156 dev_root = bus_get_dev_root(&suspend_subsys); 157 if (dev_root) { 158 rc = device_create_file(dev_root, &dev_attr_hibernate); 159 put_device(dev_root); 160 if (rc) 161 goto subsys_unregister; 162 } 163 164 return 0; 165 166 subsys_unregister: 167 bus_unregister(&suspend_subsys); 168 return rc; 169 } 170 171 /** 172 * pseries_suspend_init - initcall for pSeries suspend 173 * 174 * Return value: 175 * 0 on success / other on failure 176 **/ 177 static int __init pseries_suspend_init(void) 178 { 179 int rc; 180 181 if (!firmware_has_feature(FW_FEATURE_LPAR)) 182 return 0; 183 184 if ((rc = pseries_suspend_sysfs_register(&suspend_dev))) 185 return rc; 186 187 suspend_set_ops(&pseries_suspend_ops); 188 return 0; 189 } 190 machine_device_initcall(pseries, pseries_suspend_init); 191