arch/powerpc/platforms/pseries/suspend.c

   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/cpu.h>
  20 #include <linux/delay.h>
  21 #include <linux/suspend.h>
  22 #include <linux/stat.h>
  23 #include <asm/firmware.h>
  24 #include <asm/hvcall.h>
  25 #include <asm/machdep.h>
  26 #include <asm/mmu.h>
  27 #include <asm/rtas.h>
  28 #include <asm/topology.h>
  29 #include "../../kernel/cacheinfo.h"
  30
  31 static u64 stream_id;
  32 static struct device suspend_dev;
  33 static DECLARE_COMPLETION(suspend_work);
  34 static struct rtas_suspend_me_data suspend_data;
  35 static atomic_t suspending;
  36
  37 /**
  38  * pseries_suspend_begin - First phase of hibernation
  39  *
  40  * Check to ensure we are in a valid state to hibernate
  41  *
  42  * Return value:
  43  *      0 on success / other on failure
  44  **/
  45 static int pseries_suspend_begin(suspend_state_t state)
  46 {
  47         long vasi_state, rc;
  48         unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
  49
  50         /* Make sure the state is valid */
  51         rc = plpar_hcall(H_VASI_STATE, retbuf, stream_id);
  52
  53         vasi_state = retbuf[0];
  54
  55         if (rc) {
  56                 pr_err("pseries_suspend_begin: vasi_state returned %ld\n",rc);
  57                 return rc;
  58         } else if (vasi_state == H_VASI_ENABLED) {
  59                 return -EAGAIN;
  60         } else if (vasi_state != H_VASI_SUSPENDING) {
  61                 pr_err("pseries_suspend_begin: vasi_state returned state %ld\n",
  62                        vasi_state);
  63                 return -EIO;
  64         }
  65
  66         return 0;
  67 }
  68
  69 /**
  70  * pseries_suspend_cpu - Suspend a single CPU
  71  *
  72  * Makes the H_JOIN call to suspend the CPU
  73  *
  74  **/
  75 static int pseries_suspend_cpu(void)
  76 {
  77         if (atomic_read(&suspending))
  78                 return rtas_suspend_cpu(&suspend_data);
  79         return 0;
  80 }
  81
  82 /**
  83  * pseries_suspend_enable_irqs
  84  *
  85  * Post suspend configuration updates
  86  *
  87  **/
  88 static void pseries_suspend_enable_irqs(void)
  89 {
  90         /*
  91          * Update configuration which can be modified based on device tree
  92          * changes during resume.
  93          */
  94         cacheinfo_cpu_offline(smp_processor_id());
  95         post_mobility_fixup();
  96         cacheinfo_cpu_online(smp_processor_id());
  97 }
  98
  99 /**
 100  * pseries_suspend_enter - Final phase of hibernation
 101  *
 102  * Return value:
 103  *      0 on success / other on failure
 104  **/
 105 static int pseries_suspend_enter(suspend_state_t state)
 106 {
 107         int rc = rtas_suspend_last_cpu(&suspend_data);
 108
 109         atomic_set(&suspending, 0);
 110         atomic_set(&suspend_data.done, 1);
 111         return rc;
 112 }
 113
 114 /**
 115  * pseries_prepare_late - Prepare to suspend all other CPUs
 116  *
 117  * Return value:
 118  *      0 on success / other on failure
 119  **/
 120 static int pseries_prepare_late(void)
 121 {
 122         atomic_set(&suspending, 1);
 123         atomic_set(&suspend_data.working, 0);
 124         atomic_set(&suspend_data.done, 0);
 125         atomic_set(&suspend_data.error, 0);
 126         suspend_data.complete = &suspend_work;
 127         reinit_completion(&suspend_work);
 128         return 0;
 129 }
 130
 131 /**
 132  * store_hibernate - Initiate partition hibernation
 133  * @dev:                subsys root device
 134  * @attr:               device attribute struct
 135  * @buf:                buffer
 136  * @count:              buffer size
 137  *
 138  * Write the stream ID received from the HMC to this file
 139  * to trigger hibernating the partition
 140  *
 141  * Return value:
 142  *      number of bytes printed to buffer / other on failure
 143  **/
 144 static ssize_t store_hibernate(struct device *dev,
 145                                struct device_attribute *attr,
 146                                const char *buf, size_t count)
 147 {
 148         cpumask_var_t offline_mask;
 149         int rc;
 150
 151         if (!capable(CAP_SYS_ADMIN))
 152                 return -EPERM;
 153
 154         if (!alloc_cpumask_var(&offline_mask, GFP_TEMPORARY))
 155                 return -ENOMEM;
 156
 157         stream_id = simple_strtoul(buf, NULL, 16);
 158
 159         do {
 160                 rc = pseries_suspend_begin(PM_SUSPEND_MEM);
 161                 if (rc == -EAGAIN)
 162                         ssleep(1);
 163         } while (rc == -EAGAIN);
 164
 165         if (!rc) {
 166                 /* All present CPUs must be online */
 167                 cpumask_andnot(offline_mask, cpu_present_mask,
 168                                 cpu_online_mask);
 169                 rc = rtas_online_cpus_mask(offline_mask);
 170                 if (rc) {
 171                         pr_err("%s: Could not bring present CPUs online.\n",
 172                                         __func__);
 173                         goto out;
 174                 }
 175
 176                 stop_topology_update();
 177                 rc = pm_suspend(PM_SUSPEND_MEM);
 178                 start_topology_update();
 179
 180                 /* Take down CPUs not online prior to suspend */
 181                 if (!rtas_offline_cpus_mask(offline_mask))
 182                         pr_warn("%s: Could not restore CPUs to offline "
 183                                         "state.\n", __func__);
 184         }
 185
 186         stream_id = 0;
 187
 188         if (!rc)
 189                 rc = count;
 190 out:
 191         free_cpumask_var(offline_mask);
 192         return rc;
 193 }
 194
 195 #define USER_DT_UPDATE  0
 196 #define KERN_DT_UPDATE  1
 197
 198 /**
 199  * show_hibernate - Report device tree update responsibilty
 200  * @dev:                subsys root device
 201  * @attr:               device attribute struct
 202  * @buf:                buffer
 203  *
 204  * Report whether a device tree update is performed by the kernel after a
 205  * resume, or if drmgr must coordinate the update from user space.
 206  *
 207  * Return value:
 208  *      0 if drmgr is to initiate update, and 1 otherwise
 209  **/
 210 static ssize_t show_hibernate(struct device *dev,
 211                               struct device_attribute *attr,
 212                               char *buf)
 213 {
 214         return sprintf(buf, "%d\n", KERN_DT_UPDATE);
 215 }
 216
 217 static DEVICE_ATTR(hibernate, S_IWUSR | S_IRUGO,
 218                    show_hibernate, store_hibernate);
 219
 220 static struct bus_type suspend_subsys = {
 221         .name = "power",
 222         .dev_name = "power",
 223 };
 224
 225 static const struct platform_suspend_ops pseries_suspend_ops = {
 226         .valid          = suspend_valid_only_mem,
 227         .begin          = pseries_suspend_begin,
 228         .prepare_late   = pseries_prepare_late,
 229         .enter          = pseries_suspend_enter,
 230 };
 231
 232 /**
 233  * pseries_suspend_sysfs_register - Register with sysfs
 234  *
 235  * Return value:
 236  *      0 on success / other on failure
 237  **/
 238 static int pseries_suspend_sysfs_register(struct device *dev)
 239 {
 240         int rc;
 241
 242         if ((rc = subsys_system_register(&suspend_subsys, NULL)))
 243                 return rc;
 244
 245         dev->id = 0;
 246         dev->bus = &suspend_subsys;
 247
 248         if ((rc = device_create_file(suspend_subsys.dev_root, &dev_attr_hibernate)))
 249                 goto subsys_unregister;
 250
 251         return 0;
 252
 253 subsys_unregister:
 254         bus_unregister(&suspend_subsys);
 255         return rc;
 256 }
 257
 258 /**
 259  * pseries_suspend_init - initcall for pSeries suspend
 260  *
 261  * Return value:
 262  *      0 on success / other on failure
 263  **/
 264 static int __init pseries_suspend_init(void)
 265 {
 266         int rc;
 267
 268         if (!firmware_has_feature(FW_FEATURE_LPAR))
 269                 return 0;
 270
 271         suspend_data.token = rtas_token("ibm,suspend-me");
 272         if (suspend_data.token == RTAS_UNKNOWN_SERVICE)
 273                 return 0;
 274
 275         if ((rc = pseries_suspend_sysfs_register(&suspend_dev)))
 276                 return rc;
 277
 278         ppc_md.suspend_disable_cpu = pseries_suspend_cpu;
 279         ppc_md.suspend_enable_irqs = pseries_suspend_enable_irqs;
 280         suspend_set_ops(&pseries_suspend_ops);
 281         return 0;
 282 }
 283 machine_device_initcall(pseries, pseries_suspend_init);