powerpc/4xx: Add suspend and idle support

Add suspend/resume support for 4xx compatible CPUs.
See /sys/power/state for available power states configured in.

Add two different idle states (idle-wait and idle-doze) controlled via sysfs.
Default is idle-wait.
	cat /sys/devices/system/cpu/cpu0/idle
	[wait] doze

To save additional power, use idle-doze.
	echo doze > /sys/devices/system/cpu/cpu0/idle
	cat /sys/devices/system/cpu/cpu0/idle
	wait [doze]

Signed-off-by: Victor Gallardo <vgallardo@apm.com>
Signed-off-by: Josh Boyer <jwboyer@linux.vnet.ibm.com>

2 files changed, 347 insertions, 0 deletions

diff --git a/arch/powerpc/sysdev/Makefile b/arch/powerpc/sysdev/Makefile
index 0bef9dacb64e..9c2973479142 100644
--- a/arch/powerpc/sysdev/Makefile
+++ b/arch/powerpc/sysdev/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_OF_RTC)		+= of_rtc.o
 ifeq ($(CONFIG_PCI),y)
 obj-$(CONFIG_4xx)               += ppc4xx_pci.o
 endif
+obj-$(CONFIG_PPC4xx_CPM)        += ppc4xx_cpm.o
 obj-$(CONFIG_PPC4xx_GPIO)       += ppc4xx_gpio.o
 
 obj-$(CONFIG_CPM)               += cpm_common.o
diff --git a/arch/powerpc/sysdev/ppc4xx_cpm.c b/arch/powerpc/sysdev/ppc4xx_cpm.c
new file mode 100644
index 000000000000..73b86cc5ea74
--- /dev/null
+++ b/arch/powerpc/sysdev/ppc4xx_cpm.c
@@ -0,0 +1,346 @@
+/*
+ * PowerPC 4xx Clock and Power Management
+ *
+ * Copyright (C) 2010, Applied Micro Circuits Corporation
+ * Victor Gallardo (vgallardo@apm.com)
+ *
+ * Based on arch/powerpc/platforms/44x/idle.c:
+ * Jerone Young <jyoung5@us.ibm.com>
+ * Copyright 2008 IBM Corp.
+ *
+ * Based on arch/powerpc/sysdev/fsl_pmc.c:
+ * Anton Vorontsov <avorontsov@ru.mvista.com>
+ * Copyright 2009  MontaVista Software, Inc.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/of_platform.h>
+#include <linux/sysfs.h>
+#include <linux/cpu.h>
+#include <linux/suspend.h>
+#include <asm/dcr.h>
+#include <asm/dcr-native.h>
+#include <asm/machdep.h>
+
+#define CPM_ER  0
+#define CPM_FR  1
+#define CPM_SR  2
+
+#define CPM_IDLE_WAIT   0
+#define CPM_IDLE_DOZE   1
+
+struct cpm {
+        dcr_host_t      dcr_host;
+        unsigned int    dcr_offset[3];
+        unsigned int    powersave_off;
+        unsigned int    unused;
+        unsigned int    idle_doze;
+        unsigned int    standby;
+        unsigned int    suspend;
+};
+
+static struct cpm cpm;
+
+struct cpm_idle_mode {
+        unsigned int enabled;
+        const char  *name;
+};
+
+static struct cpm_idle_mode idle_mode[] = {
+        [CPM_IDLE_WAIT] = { 1, "wait" }, /* default */
+        [CPM_IDLE_DOZE] = { 0, "doze" },
+};
+
+static unsigned int cpm_set(unsigned int cpm_reg, unsigned int mask)
+{
+        unsigned int value;
+
+        /* CPM controller supports 3 different types of sleep interface
+         * known as class 1, 2 and 3. For class 1 units, they are
+         * unconditionally put to sleep when the corresponding CPM bit is
+         * set. For class 2 and 3 units this is not case; if they can be
+         * put to to sleep, they will. Here we do not verify, we just
+         * set them and expect them to eventually go off when they can.
+         */
+        value = dcr_read(cpm.dcr_host, cpm.dcr_offset[cpm_reg]);
+        dcr_write(cpm.dcr_host, cpm.dcr_offset[cpm_reg], value | mask);
+
+        /* return old state, to restore later if needed */
+        return value;
+}
+
+static void cpm_idle_wait(void)
+{
+        unsigned long msr_save;
+
+        /* save off initial state */
+        msr_save = mfmsr();
+        /* sync required when CPM0_ER[CPU] is set */
+        mb();
+        /* set wait state MSR */
+        mtmsr(msr_save|MSR_WE|MSR_EE|MSR_CE|MSR_DE);
+        isync();
+        /* return to initial state */
+        mtmsr(msr_save);
+        isync();
+}
+
+static void cpm_idle_sleep(unsigned int mask)
+{
+        unsigned int er_save;
+
+        /* update CPM_ER state */
+        er_save = cpm_set(CPM_ER, mask);
+
+        /* go to wait state so that CPM0_ER[CPU] can take effect */
+        cpm_idle_wait();
+
+        /* restore CPM_ER state */
+        dcr_write(cpm.dcr_host, cpm.dcr_offset[CPM_ER], er_save);
+}
+
+static void cpm_idle_doze(void)
+{
+        cpm_idle_sleep(cpm.idle_doze);
+}
+
+static void cpm_idle_config(int mode)
+{
+        int i;
+
+        if (idle_mode[mode].enabled)
+                return;
+
+        for (i = 0; i < ARRAY_SIZE(idle_mode); i++)
+                idle_mode[i].enabled = 0;
+
+        idle_mode[mode].enabled = 1;
+}
+
+static ssize_t cpm_idle_show(struct kobject *kobj,
+                             struct kobj_attribute *attr, char *buf)
+{
+        char *s = buf;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
+                if (idle_mode[i].enabled)
+                        s += sprintf(s, "[%s] ", idle_mode[i].name);
+                else
+                        s += sprintf(s, "%s ", idle_mode[i].name);
+        }
+
+        *(s-1) = '\n'; /* convert the last space to a newline */
+
+        return s - buf;
+}
+
+static ssize_t cpm_idle_store(struct kobject *kobj,
+                              struct kobj_attribute *attr,
+                              const char *buf, size_t n)
+{
+        int i;
+        char *p;
+        int len;
+
+        p = memchr(buf, '\n', n);
+        len = p ? p - buf : n;
+
+        for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
+                if (strncmp(buf, idle_mode[i].name, len) == 0) {
+                        cpm_idle_config(i);
+                        return n;
+                }
+        }
+
+        return -EINVAL;
+}
+
+static struct kobj_attribute cpm_idle_attr =
+        __ATTR(idle, 0644, cpm_idle_show, cpm_idle_store);
+