arch/powerpc/platforms/4xx/cpm.c

   1 /*
   2  * PowerPC 4xx Clock and Power Management
   3  *
   4  * Copyright (C) 2010, Applied Micro Circuits Corporation
   5  * Victor Gallardo (vgallardo@apm.com)
   6  *
   7  * Based on arch/powerpc/platforms/44x/idle.c:
   8  * Jerone Young <jyoung5@us.ibm.com>
   9  * Copyright 2008 IBM Corp.
  10  *
  11  * Based on arch/powerpc/sysdev/fsl_pmc.c:
  12  * Anton Vorontsov <avorontsov@ru.mvista.com>
  13  * Copyright 2009  MontaVista Software, Inc.
  14  *
  15  * See file CREDITS for list of people who contributed to this
  16  * project.
  17  *
  18  * This program is free software; you can redistribute it and/or
  19  * modify it under the terms of the GNU General Public License as
  20  * published by the Free Software Foundation; either version 2 of
  21  * the License, or (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  31  * MA 02111-1307 USA
  32  */
  33
  34 #include <linux/kernel.h>
  35 #include <linux/of_platform.h>
  36 #include <linux/sysfs.h>
  37 #include <linux/cpu.h>
  38 #include <linux/suspend.h>
  39 #include <asm/dcr.h>
  40 #include <asm/dcr-native.h>
  41 #include <asm/machdep.h>
  42
  43 #define CPM_ER  0
  44 #define CPM_FR  1
  45 #define CPM_SR  2
  46
  47 #define CPM_IDLE_WAIT   0
  48 #define CPM_IDLE_DOZE   1
  49
  50 struct cpm {
  51         dcr_host_t      dcr_host;
  52         unsigned int    dcr_offset[3];
  53         unsigned int    powersave_off;
  54         unsigned int    unused;
  55         unsigned int    idle_doze;
  56         unsigned int    standby;
  57         unsigned int    suspend;
  58 };
  59
  60 static struct cpm cpm;
  61
  62 struct cpm_idle_mode {
  63         unsigned int enabled;
  64         const char  *name;
  65 };
  66
  67 static struct cpm_idle_mode idle_mode[] = {
  68         [CPM_IDLE_WAIT] = { 1, "wait" }, /* default */
  69         [CPM_IDLE_DOZE] = { 0, "doze" },
  70 };
  71
  72 static unsigned int cpm_set(unsigned int cpm_reg, unsigned int mask)
  73 {
  74         unsigned int value;
  75
  76         /* CPM controller supports 3 different types of sleep interface
  77          * known as class 1, 2 and 3. For class 1 units, they are
  78          * unconditionally put to sleep when the corresponding CPM bit is
  79          * set. For class 2 and 3 units this is not case; if they can be
  80          * put to to sleep, they will. Here we do not verify, we just
  81          * set them and expect them to eventually go off when they can.
  82          */
  83         value = dcr_read(cpm.dcr_host, cpm.dcr_offset[cpm_reg]);
  84         dcr_write(cpm.dcr_host, cpm.dcr_offset[cpm_reg], value | mask);
  85
  86         /* return old state, to restore later if needed */
  87         return value;
  88 }
  89
  90 static void cpm_idle_wait(void)
  91 {
  92         unsigned long msr_save;
  93
  94         /* save off initial state */
  95         msr_save = mfmsr();
  96         /* sync required when CPM0_ER[CPU] is set */
  97         mb();
  98         /* set wait state MSR */
  99         mtmsr(msr_save|MSR_WE|MSR_EE|MSR_CE|MSR_DE);
 100         isync();
 101         /* return to initial state */
 102         mtmsr(msr_save);
 103         isync();
 104 }
 105
 106 static void cpm_idle_sleep(unsigned int mask)
 107 {
 108         unsigned int er_save;
 109
 110         /* update CPM_ER state */
 111         er_save = cpm_set(CPM_ER, mask);
 112
 113         /* go to wait state so that CPM0_ER[CPU] can take effect */
 114         cpm_idle_wait();
 115
 116         /* restore CPM_ER state */
 117         dcr_write(cpm.dcr_host, cpm.dcr_offset[CPM_ER], er_save);
 118 }
 119
 120 static void cpm_idle_doze(void)
 121 {
 122         cpm_idle_sleep(cpm.idle_doze);
 123 }
 124
 125 static void cpm_idle_config(int mode)
 126 {
 127         int i;
 128
 129         if (idle_mode[mode].enabled)
 130                 return;
 131
 132         for (i = 0; i < ARRAY_SIZE(idle_mode); i++)
 133                 idle_mode[i].enabled = 0;
 134
 135         idle_mode[mode].enabled = 1;
 136 }
 137
 138 static ssize_t cpm_idle_show(struct kobject *kobj,
 139                              struct kobj_attribute *attr, char *buf)
 140 {
 141         char *s = buf;
 142         int i;
 143
 144         for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
 145                 if (idle_mode[i].enabled)
 146                         s += sprintf(s, "[%s] ", idle_mode[i].name);
 147                 else
 148                         s += sprintf(s, "%s ", idle_mode[i].name);
 149         }
 150
 151         *(s-1) = '\n'; /* convert the last space to a newline */
 152
 153         return s - buf;
 154 }
 155
 156 static ssize_t cpm_idle_store(struct kobject *kobj,
 157                               struct kobj_attribute *attr,
 158                               const char *buf, size_t n)
 159 {
 160         int i;
 161         char *p;
 162         int len;
 163
 164         p = memchr(buf, '\n', n);
 165         len = p ? p - buf : n;
 166
 167         for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
 168                 if (strncmp(buf, idle_mode[i].name, len) == 0) {
 169                         cpm_idle_config(i);
 170                         return n;
 171                 }
 172         }
 173
 174         return -EINVAL;
 175 }
 176
 177 static struct kobj_attribute cpm_idle_attr =
 178         __ATTR(idle, 0644, cpm_idle_show, cpm_idle_store);
 179
 180 static void cpm_idle_config_sysfs(void)
 181 {
 182         struct device *dev;
 183         unsigned long ret;
 184
 185         dev = get_cpu_device(0);
 186
 187         ret = sysfs_create_file(&dev->kobj,
 188                                 &cpm_idle_attr.attr);
 189         if (ret)
 190                 printk(KERN_WARNING
 191                        "cpm: failed to create idle sysfs entry\n");
 192 }
 193
 194 static void cpm_idle(void)
 195 {
 196         if (idle_mode[CPM_IDLE_DOZE].enabled)
 197                 cpm_idle_doze();
 198         else
 199                 cpm_idle_wait();
 200 }
 201
 202 static int cpm_suspend_valid(suspend_state_t state)
 203 {
 204         switch (state) {
 205         case PM_SUSPEND_STANDBY:
 206                 return !!cpm.standby;
 207         case PM_SUSPEND_MEM:
 208                 return !!cpm.suspend;
 209         default:
 210                 return 0;
 211         }
 212 }
 213
 214 static void cpm_suspend_standby(unsigned int mask)
 215 {
 216         unsigned long tcr_save;
 217
 218         /* disable decrement interrupt */
 219         tcr_save = mfspr(SPRN_TCR);
 220         mtspr(SPRN_TCR, tcr_save & ~TCR_DIE);
 221
 222         /* go to sleep state */
 223         cpm_idle_sleep(mask);
 224
 225         /* restore decrement interrupt */
 226         mtspr(SPRN_TCR, tcr_save);
 227 }
 228
 229 static int cpm_suspend_enter(suspend_state_t state)
 230 {
 231         switch (state) {
 232         case PM_SUSPEND_STANDBY:
 233                 cpm_suspend_standby(cpm.standby);
 234                 break;
 235         case PM_SUSPEND_MEM:
 236                 cpm_suspend_standby(cpm.suspend);
 237                 break;
 238         }
 239
 240         return 0;
 241 }
 242
 243 static const struct platform_suspend_ops cpm_suspend_ops = {
 244         .valid          = cpm_suspend_valid,
 245         .enter          = cpm_suspend_enter,
 246 };
 247
 248 static int cpm_get_uint_property(struct device_node *np,
 249                                  const char *name)
 250 {
 251         int len;
 252         const unsigned int *prop = of_get_property(np, name, &len);
 253
 254         if (prop == NULL || len < sizeof(u32))
 255                 return 0;
 256
 257         return *prop;
 258 }
 259
 260 static int __init cpm_init(void)
 261 {
 262         struct device_node *np;
 263         int dcr_base, dcr_len;
 264         int ret = 0;
 265
 266         if (!cpm.powersave_off) {
 267                 cpm_idle_config(CPM_IDLE_WAIT);
 268                 ppc_md.power_save = &cpm_idle;
 269         }
 270
 271         np = of_find_compatible_node(NULL, NULL, "ibm,cpm");
 272         if (!np) {
 273                 ret = -EINVAL;
 274                 goto out;
 275         }
 276
 277         dcr_base = dcr_resource_start(np, 0);
 278         dcr_len = dcr_resource_len(np, 0);
 279
 280         if (dcr_base == 0 || dcr_len == 0) {
 281                 printk(KERN_ERR "cpm: could not parse dcr property for %pOF\n",
 282                        np);
 283                 ret = -EINVAL;
 284                 goto node_put;
 285         }
 286
 287         cpm.dcr_host = dcr_map(np, dcr_base, dcr_len);
 288
 289         if (!DCR_MAP_OK(cpm.dcr_host)) {
 290                 printk(KERN_ERR "cpm: failed to map dcr property for %pOF\n",
 291                        np);
 292                 ret = -EINVAL;
 293                 goto node_put;
 294         }
 295
 296         /* All 4xx SoCs with a CPM controller have one of two
 297          * different order for the CPM registers. Some have the
 298          * CPM registers in the following order (ER,FR,SR). The
 299          * others have them in the following order (SR,ER,FR).
 300          */
 301
 302         if (cpm_get_uint_property(np, "er-offset") == 0) {
 303                 cpm.dcr_offset[CPM_ER] = 0;
 304                 cpm.dcr_offset[CPM_FR] = 1;
 305                 cpm.dcr_offset[CPM_SR] = 2;
 306         } else {
 307                 cpm.dcr_offset[CPM_ER] = 1;
 308                 cpm.dcr_offset[CPM_FR] = 2;
 309                 cpm.dcr_offset[CPM_SR] = 0;
 310         }
 311
 312         /* Now let's see what IPs to turn off for the following modes */
 313
 314         cpm.unused = cpm_get_uint_property(np, "unused-units");
 315         cpm.idle_doze = cpm_get_uint_property(np, "idle-doze");
 316         cpm.standby = cpm_get_uint_property(np, "standby");
 317         cpm.suspend = cpm_get_uint_property(np, "suspend");
 318
 319         /* If some IPs are unused let's turn them off now */
 320
 321         if (cpm.unused) {
 322                 cpm_set(CPM_ER, cpm.unused);
 323                 cpm_set(CPM_FR, cpm.unused);
 324         }
 325
 326         /* Now let's export interfaces */
 327
 328         if (!cpm.powersave_off && cpm.idle_doze)
 329                 cpm_idle_config_sysfs();
 330
 331         if (cpm.standby || cpm.suspend)
 332                 suspend_set_ops(&cpm_suspend_ops);
 333 node_put:
 334         of_node_put(np);
 335 out:
 336         return ret;
 337 }
 338
 339 late_initcall(cpm_init);
 340
 341 static int __init cpm_powersave_off(char *arg)
 342 {
 343         cpm.powersave_off = 1;
 344         return 0;
 345 }
 346 __setup("powersave=off", cpm_powersave_off);