1/* 2 * Copyright (C) 2010 Brian King IBM Corporation 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 17 */ 18 19#include <linux/delay.h> 20#include <linux/suspend.h> 21#include <asm/firmware.h> 22#include <asm/hvcall.h> 23#include <asm/machdep.h> 24#include <asm/mmu.h> 25#include <asm/rtas.h> 26 27static u64 stream_id; 28static struct sys_device suspend_sysdev; 29static DECLARE_COMPLETION(suspend_work); 30static struct rtas_suspend_me_data suspend_data; 31static atomic_t suspending; 32 33/** 34 * pseries_suspend_begin - First phase of hibernation 35 * 36 * Check to ensure we are in a valid state to hibernate 37 * 38 * Return value: 39 * 0 on success / other on failure 40 **/ 41static int pseries_suspend_begin(suspend_state_t state) 42{ 43 long vasi_state, rc; 44 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 45 46 /* Make sure the state is valid */ 47 rc = plpar_hcall(H_VASI_STATE, retbuf, stream_id); 48 49 vasi_state = retbuf[0]; 50 51 if (rc) { 52 pr_err("pseries_suspend_begin: vasi_state returned %ld\n",rc); 53 return rc; 54 } else if (vasi_state == H_VASI_ENABLED) { 55 return -EAGAIN; 56 } else if (vasi_state != H_VASI_SUSPENDING) { 57 pr_err("pseries_suspend_begin: vasi_state returned state %ld\n", 58 vasi_state); 59 return -EIO; 60 } 61 62 return 0; 63} 64 65/** 66 * pseries_suspend_cpu - Suspend a single CPU 67 * 68 * Makes the H_JOIN call to suspend the CPU 69 * 70 **/ 71static int pseries_suspend_cpu(void) 72{ 73 if (atomic_read(&suspending)) 74 return rtas_suspend_cpu(&suspend_data); 75 return 0; 76} 77 78/** 79 * pseries_suspend_enter - Final phase of hibernation 80 * 81 * Return value: 82 * 0 on success / other on failure 83 **/ 84static int pseries_suspend_enter(suspend_state_t state) 85{ 86 int rc = rtas_suspend_last_cpu(&suspend_data); 87 88 atomic_set(&suspending, 0); 89 atomic_set(&suspend_data.done, 1); 90 return rc; 91} 92 93/** 94 * pseries_prepare_late - Prepare to suspend all other CPUs 95 * 96 * Return value: 97 * 0 on success / other on failure 98 **/ 99static int pseries_prepare_late(void) 100{ 101 atomic_set(&suspending, 1); 102 atomic_set(&suspend_data.working, 0); 103 atomic_set(&suspend_data.done, 0); 104 atomic_set(&suspend_data.error, 0); 105 suspend_data.complete = &suspend_work; 106 INIT_COMPLETION(suspend_work); 107 return 0; 108} 109 110/** 111 * store_hibernate - Initiate partition hibernation 112 * @classdev: sysdev class struct 113 * @attr: class device attribute struct 114 * @buf: buffer 115 * @count: buffer size 116 * 117 * Write the stream ID received from the HMC to this file 118 * to trigger hibernating the partition 119 * 120 * Return value: 121 * number of bytes printed to buffer / other on failure 122 **/ 123static ssize_t store_hibernate(struct sysdev_class *classdev, 124 struct sysdev_class_attribute *attr, 125 const char *buf, size_t count) 126{ 127 int rc; 128 129 if (!capable(CAP_SYS_ADMIN)) 130 return -EPERM; 131 132 stream_id = simple_strtoul(buf, NULL, 16); 133 134 do { 135 rc = pseries_suspend_begin(PM_SUSPEND_MEM); 136 if (rc == -EAGAIN) 137 ssleep(1); 138 } while (rc == -EAGAIN); 139 140 if (!rc) 141 rc = pm_suspend(PM_SUSPEND_MEM); 142 143 stream_id = 0; 144 145 if (!rc) 146 rc = count; 147 return rc; 148} 149 150static SYSDEV_CLASS_ATTR(hibernate, S_IWUSR, NULL, store_hibernate); 151 152static struct sysdev_class suspend_sysdev_class = { 153 .name = "power", 154}; 155 156static struct platform_suspend_ops pseries_suspend_ops = { 157 .valid = suspend_valid_only_mem, 158 .begin = pseries_suspend_begin, 159 .prepare_late = pseries_prepare_late, 160 .enter = pseries_suspend_enter, 161}; 162 163/** 164 * pseries_suspend_sysfs_register - Register with sysfs 165 * 166 * Return value: 167 * 0 on success / other on failure 168 **/ 169static int pseries_suspend_sysfs_register(struct sys_device *sysdev) 170{ 171 int rc; 172 173 if ((rc = sysdev_class_register(&suspend_sysdev_class))) 174 return rc; 175 176 sysdev->id = 0; 177 sysdev->cls = &suspend_sysdev_class; 178 179 if ((rc = sysdev_class_create_file(&suspend_sysdev_class, &attr_hibernate))) 180 goto class_unregister; 181 182 return 0; 183 184class_unregister: 185 sysdev_class_unregister(&suspend_sysdev_class); 186 return rc; 187} 188 189/** 190 * pseries_suspend_init - initcall for pSeries suspend 191 * 192 * Return value: 193 * 0 on success / other on failure 194 **/ 195static int __init pseries_suspend_init(void) 196{ 197 int rc; 198 199 if (!machine_is(pseries) || !firmware_has_feature(FW_FEATURE_LPAR)) 200 return 0; 201 202 suspend_data.token = rtas_token("ibm,suspend-me"); 203 if (suspend_data.token == RTAS_UNKNOWN_SERVICE) 204 return 0; 205 206 if ((rc = pseries_suspend_sysfs_register(&suspend_sysdev))) 207 return rc; 208 209 ppc_md.suspend_disable_cpu = pseries_suspend_cpu; 210 suspend_set_ops(&pseries_suspend_ops); 211 return 0; 212} 213 214__initcall(pseries_suspend_init); 215