gpl-source-mybooklive-010002-update.zipgpl-source-mybooklive-010103-update.zipgpl-source-mybooklive-010002-update.zip

1 files changed, 636 insertions, 0 deletions

diff --git a/arch/powerpc/sysdev/ppc4xx_cpm.c b/arch/powerpc/sysdev/ppc4xx_cpm.c
new file mode 100644
index 00000000000..d0804f0d316
--- /dev/null
+++ b/arch/powerpc/sysdev/ppc4xx_cpm.c
@@ -0,0 +1,636 @@
+/*
+ * arch/powerpc/sysdev/ppc4xx_cpm.c
+ *
+ * PowerPC 4xx Clock and Power Management
+ *
+ * (C) Copyright 2009, Applied Micro Circuits Corporation
+ * Victor Gallardo (vgallardo@amcc.com)
+ *
+ * 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/errno.h>
+#include <linux/proc_fs.h>
+#include <linux/dma-mapping.h>
+#include <asm/uaccess.h>
+#include <asm/prom.h>
+#include <asm/io.h>
+#include <asm/dcr.h>
+#include <asm/dcr-regs.h>
+#include <asm/mmio-regs.h>
+#include <asm/ppc4xx_cpm.h>
+#include <asm/ppc4xx_ocm.h>
+
+#define CPM_PM_MEM_DATA_SIZE	(256*sizeof(unsigned  long))
+#define CPM_PM_MEM_ALIGN	16
+
+#define CPM_ER	0x0
+#define CPM_FR	0x1
+#define CPM_SR	0x2
+
+#define CPM_PCIE_SLEEP	0x00040000
+#define CPM_SATA0_SLEEP	0x00001000
+
+extern void cpm_suspend_mem(int pm_mode, unsigned long *data, void *resume);
+extern const long cpm_suspend_mem_size;
+
+extern void cpm_resume_mem(void);
+extern const long cpm_resume_mem_size;
+
+struct cpm_pm_mem {
+	/* functions in OCM */
+	void (*suspend)(int pm_mode, unsigned long *data, void *resume);
+	void (*resume )(void);
+	/* data OCM */
+	unsigned long	*data;
+};
+
+struct cpm_pm_iic {
+	phys_addr_t	phys;
+	size_t		size;
+};
+
+struct cpm_pm_emac {
+	phys_addr_t phys;
+	size_t		size;
+};
+
+struct cpm {
+	unsigned int index;
+	unsigned int dcrbase;
+	unsigned int ready;
+	unsigned int save_er;
+	unsigned int save_fr;
+	unsigned int pm_cpu;
+	unsigned int pm_off;
+	unsigned int pm_doze;
+	unsigned int pm_nap;
+	unsigned int pm_deepsleep;
+	struct cpm_pm_iic pm_iic;
+	struct cpm_pm_emac pm_emac;
+};
+
+extern int	pcie_used;
+
+//static struct proc_dir_entry * cpm_proc_entry;
+
+static struct cpm *cpm_nodes = NULL;
+static int cpm_count = 0;
+
+static struct cpm_pm_mem cpm_pm_mem;
+
+static u32 dcrbase_l2c = 0;
+
+const char *cpm_mode_name(int mode)
+{
+        switch (mode) {
+        case CPM_PM_DOZE:
+                return "doze";
+        case CPM_PM_NAP:
+                return "nap";
+        case CPM_PM_DEEPSLEEP:
+                return "deepsleep";
+        default:
+                BUG();
+        }
+}
+
+static struct cpm * get_cpm_node(unsigned int index)
+{
+        BUG_ON(index >= cpm_count);
+
+	return &cpm_nodes[index];
+}
+
+static int cpm_enable(unsigned int index, unsigned int val)
+{
+	struct cpm *cpm = get_cpm_node(index);
+
+	mtdcr(cpm->dcrbase + CPM_ER,
+	      mfdcr(cpm->dcrbase + CPM_ER) | val);
+
+	return 0;
+}
+
+static int cpm_force_enable(unsigned int index, unsigned int val)
+{
+	struct cpm *cpm = get_cpm_node(index);
+
+	mtdcr(cpm->dcrbase + CPM_FR,
+	      mfdcr(cpm->dcrbase + CPM_FR) | val);
+
+	while ((mfdcr(cpm->dcrbase + CPM_SR) & val) != val);
+
+	return 0;
+}
+
+static int cpm_save(unsigned int index)
+{
+	struct cpm *cpm = get_cpm_node(index);
+
+	cpm->save_er = mfdcr(cpm->dcrbase + CPM_ER);
+	cpm->save_fr = mfdcr(cpm->dcrbase + CPM_FR);
+
+	return 0;
+}
+
+static int cpm_restore(unsigned int index)
+{
+	struct cpm *cpm = get_cpm_node(index);
+
+	mtdcr(cpm->dcrbase + CPM_ER, cpm->save_er);
+	mtdcr(cpm->dcrbase + CPM_FR, cpm->save_fr);
+
+	while ((mfdcr(cpm->dcrbase + CPM_SR) & cpm->save_fr) != cpm->save_fr);
+
+	return 0;
+}
+
+static int cpm_pm_enable(int pm_mode)
+{
+	unsigned int i;
+	unsigned int pm_val;
+
+	for (i=0; i < cpm_count; i++) {
+		struct cpm *cpm = get_cpm_node(i);
+
+		switch(pm_mode) {
+		case CPM_PM_DOZE:
+			pm_val = cpm->pm_doze;
+			break;
+		case CPM_PM_NAP:
+			pm_val = cpm->pm_nap;
+			break;
+		case CPM_PM_DEEPSLEEP:
+			pm_val = cpm->pm_deepsleep;
+			break;
+		default:
+			return -EINVAL;
+		}
+
+		cpm_save(i);
+		cpm_enable(i, pm_val);
+		cpm_force_enable(i, pm_val);
+	}
+
+	return 0;
+}
+
+static int cpm_pm_disable(int pm_mode)
+{
+	unsigned int i;
+
+	for (i=0; i < cpm_count; i++) {
+		switch(pm_mode) {
+		case CPM_PM_DOZE:
+		case CPM_PM_NAP:
+		case CPM_PM_DEEPSLEEP:
+			cpm_restore(i);
+			break;
+		default:
+			return -EINVAL;
+		}
+	}
+
+	return 0;
+}
+
+static void cpm_flush_caches(void)
+{
+	struct page *page;
+	size_t size = PAGE_ALIGN(0x8000);
+	unsigned long order = get_order(size);
+
+	/* Flush and invalidate L1 cache */
+	page = alloc_pages(GFP_NOWAIT, order);
+	if (page) {
+		unsigned long kaddr = (unsigned long)page_address(page);
+		unsigned long endaddr = kaddr + size;
+		unsigned long addr;
+
+		for (addr = kaddr; addr < endaddr; addr += L1_CACHE_BYTES)
+			asm ("dcbt 0,%0": :"r" (addr));
+		asm ("sync");
+
+		for (addr = kaddr; addr < endaddr; addr += L1_CACHE_BYTES)
+			asm ("dcbf 0,%0": :"r" (addr));
+		asm ("sync");
+		asm ("isync");
+
+		__free_pages(page, order);
+	}
+
+	if (dcrbase_l2c != 0)  {
+		/* Invalidate L2 cache using the Hardware Clear Command */
+		mtdcr(dcrbase_l2c + DCRN_L2C0_ADDR, 0);
+		mtdcr(dcrbase_l2c + DCRN_L2C0_CMD, L2C_CMD_HCC);
+
+		/* Wait for Command Complete to set */
+		while (!(mfdcr(dcrbase_l2c + DCRN_L2C0_SR) & L2C_SR_CC))
+			;
+		//printk(KERN_INFO "%s\n", __func__);
+	}
+}
+
+static int cpm_pm_mem_idle(int pm_mode)
+{
+	void __iomem *iicp = NULL;
+
+	if (pm_mode < CPM_PM_NAP)
+		return -EINVAL;
+
+	if ( !cpm_pm_mem.suspend || !cpm_pm_mem.resume ||!cpm_pm_mem.data)
+		return -ENOMEM;
+
+	printk(KERN_INFO "%s\n", __func__);
+
+	if (pm_mode == CPM_PM_DEEPSLEEP) {
+		/* FIXME: Disable I2C interrupbecause it causes interrupt that wake up the system */
+		struct cpm *cpm = get_cpm_node(0);
+		iicp = ioremap(cpm->pm_iic.phys, cpm->pm_iic.size);
+		cpm_pm_mem.data[CPM_PM_DATA_IIC_PTR] = (unsigned long)iicp;
+	}
+
+	if (!iicp) {
+		printk(KERN_INFO "No iic\n");
+		pm_mode = CPM_PM_NAP;
+	} else {
+		printk(KERN_INFO "%s: iic address = 0x%p\n",
+			__func__, iicp);
+		printk(KERN_INFO "%s: iic status = 0x%02x\n",
+			__func__, in_8(iicp+IIC_STS));
+	}
+	/* call OCM code */
+	cpm_pm_mem.suspend(pm_mode, cpm_pm_mem.data, cpm_pm_mem.resume);
+	printk(KERN_INFO "%s: wakeup\n", __func__);
+
+	if (iicp)
+		iounmap(iicp);
+
+	return 0;
+}
+
+int cpm_pm_idle(int pm_mode)
+{
+	unsigned long tcr_save = 0;
+	unsigned long ccr0_save = 0;
+	int emac0_mr0;
+	void __iomem *emacp = NULL;
+	struct cpm *cpm;
+
+	printk(KERN_INFO "%s\n", __func__);
+
+
+	cpm = get_cpm_node(0);
+	emacp = ioremap(cpm->pm_emac.phys, cpm->pm_emac.size);
+	if (emacp) {
+		emac0_mr0 = in_be32(emacp + 0);
+		/*printk(KERN_INFO "EMAC0_MR0 value before set WOL:0x%x\n", emac0_mr0);*/
+ 		emac0_mr0 &= CPM_PM_DISABLE_EMAC0_MR0_RXE;
+ 		out_be32(emacp + 0, emac0_mr0);
+ 		emac0_mr0 = in_be32(emacp + 0);
+		while (!(emac0_mr0 & CPM_PM_EMAC0_MR0_RXI
+					 && !(emac0_mr0 & CPM_PM_ENABLE_EMAC0_MR0_RXE))) {
+			emac0_mr0 = in_be32(emacp + 0);
+		}
+ 		emac0_mr0 |= CPM_PM_ENABLE_EMAC0_MR0_WKE;
+ 		out_be32(emacp + 0, emac0_mr0);
+		emac0_mr0 = in_be32(emacp + 0);
+		emac0_mr0 |= CPM_PM_ENABLE_EMAC0_MR0_RXE;
+		out_be32(emacp + 0, emac0_mr0);
+		/*printk(KERN_INFO "EMAC0_MR0 value after set WOL:0x%x\n", emac0_mr0);*/
+	}
+
+	ccr0_save = mfspr(SPRN_CCR0);
+	tcr_save = mfspr(SPRN_TCR);
+	mtspr(SPRN_TCR, tcr_save & ~TCR_DIE);
+	mtspr(SPRN_CCR0, ccr0_save | CCR0_DTB | CCR0_GDCBT);
+
+	cpm_flush_caches();
+	cpm_pm_enable(pm_mode);
+	
+
+	if (cpm_pm_mem_idle(pm_mode) < 0) {
+                unsigned long msr_save;
+
+		/* set wait state MSR */
+		msr_save = mfmsr();
+                mtmsr(msr_save|MSR_WE|MSR_EE|MSR_CE|MSR_DE);
+                isync();
+                /* return to initial state */
+                mtmsr(msr_save);
+                isync();
+	}
+
+	cpm_pm_disable(pm_mode);
+	mtspr(SPRN_CCR0, ccr0_save);
+	mtspr(SPRN_TCR, tcr_save);
+	
+  	if (emacp) {
+ 		emac0_mr0 = in_be32(emacp + 0);
+		emac0_mr0 &= CPM_PM_DISABLE_EMAC0_MR0_RXE;
+		out_be32(emacp + 0, emac0_mr0);
+		emac0_mr0 = in_be32(emacp + 0);
+		while (!(emac0_mr0 & CPM_PM_EMAC0_MR0_RXI 
+				&& !(emac0_mr0 & CPM_PM_ENABLE_EMAC0_MR0_RXE))) {
+			emac0_mr0 = in_be32(emacp + 0);
+		}
+		emac0_mr0 &= CPM_PM_DISABLE_EMAC0_MR0_WKE;
+ 		out_be32(emacp + 0, emac0_mr0);
+		emac0_mr0 = in_be32(emacp + 0);
+		emac0_mr0 |= CPM_PM_ENABLE_EMAC0_MR0_RXE;
+		out_be32(emacp + 0, emac0_mr0);
+		/*printk(KERN_INFO "EMAC0_MR0 value after disable WOL:0x%x\n", emac0_mr0);*/
+	}
+
+	printk(KERN_INFO "%s: wakeup\n", __func__);
+
+	return 0;
+}
+
+
+int cpm_pm_suspend(suspend_state_t state, int suspend_mode)
+{
+	int pm_mode;
+
+	switch (state) {
+	case PM_SUSPEND_STANDBY:
+		/* standby only support DOZE */
+		pm_mode = CPM_PM_DOZE;
+		break;
+	case PM_SUSPEND_MEM:
+		if (suspend_mode < CPM_PM_NAP)
+			suspend_mode = CPM_PM_DOZE;
+		pm_mode = suspend_mode;
+		break;
+	default:
+		printk(KERN_INFO "%s: -EINVAL\n", __func__);
+		return -EINVAL;
+	}
+
+	cpm_pm_idle(pm_mode);
+
+	return 0;
+}
+
+static void __init cpm_get_pm_emac(struct cpm *cpm, struct device_node *node)
+{
+	const phandle *phandle;
+	struct device_node *dev_node;
+	struct resource rsrc;
+
+	phandle = of_get_property(node, "pm-emac-device", NULL);
+	if (!phandle) {
+		printk(KERN_INFO "CPM%d: pm-memory property not defined\n",
+			cpm->index);
+		return;
+	}
+
+	dev_node = of_find_node_by_phandle(*phandle);
+	if (!dev_node) {
+		printk(KERN_ERR "CPM%d: Can't find pm-emac-device node\n",
+			cpm->index);
+		return;
+	}
+
+	printk(KERN_INFO "CPM%d: pm-emac-device resource %s\n",
+		cpm->index, dev_node->full_name);
+
+	if (of_address_to_resource(dev_node, 0, &rsrc)) {
+		printk(KERN_ERR "CPM%d: Can't get address to %s resource\n",
+			cpm->index, dev_node->full_name);
+		return;
+	}
+
+	cpm->pm_emac.phys = rsrc.start;
+	cpm->pm_emac.size = rsrc.end - rsrc.start + 1;
+}
+
+static void __init cpm_get_pm_iic(struct cpm *cpm, struct device_node *node)
+{
+	const phandle *phandle;
+	struct device_node *dev_node;
+	struct resource rsrc;
+
+	phandle = of_get_property(node, "pm-iic-device", NULL);
+	if (!phandle) {
+		printk(KERN_INFO "CPM%d: pm-memory property not defined\n",
+			cpm->index);
+		return;
+	}
+
+	dev_node = of_find_node_by_phandle(*phandle);
+	if (!dev_node) {
+		printk(KERN_ERR "CPM%d: Can't find pm-iic-device node\n",
+			cpm->index);
+		return;
+	}
+
+	printk(KERN_INFO "CPM%d: pm-iic-device resource %s\n",
+		cpm->index, dev_node->full_name);
+
+	if (of_address_to_resource(dev_node, 0, &rsrc)) {
+		printk(KERN_ERR "CPM%d: Can't get address to %s resource\n",
+			cpm->index, dev_node->full_name);
+		return;
+	}
+
+	cpm->pm_iic.phys = rsrc.start;
+	cpm->pm_iic.size = rsrc.end - rsrc.start + 1;
+
+	//printk(KERN_INFO "CPM%d: pm-iic-device address 0x%llx\n",
+		//cpm->index, cpm->pm_iic.phys);
+}
+
+static void __init cpm_init_node(struct device_node *node)
+{
+	struct cpm *cpm;
+	const unsigned int *cell_index;
+	const unsigned int *dcr_reg;
+	const unsigned int *pm_cpu;
+	const unsigned int *pm_off;
+	const unsigned int *pm_doze;
+	const unsigned int *pm_nap;
+	const unsigned int *pm_deepsleep;
+	int len;
+
+	cell_index = of_get_property(node, "cell-index", &len);
+	if (!cell_index)
+        	BUG_ON("cpm: missing cell-index property");
+	else if ((len != sizeof(unsigned int)) || *cell_index >= cpm_count)
+        	BUG_ON("cpm: invalid cell-index property");
+	else if (cpm_nodes[*cell_index].ready)
+		BUG_ON("cpm: duplicate cell-index property");
+
+	cpm = &cpm_nodes[*cell_index];
+	cpm->index = *cell_index;
+
+	dcr_reg = of_get_property(node, "dcr-reg", &len);
+	if (!dcr_reg || (len != 2*sizeof(unsigned int)))
+		BUG_ON("cpm: missing or invalid dcr-reg property");
+
+	cpm->dcrbase = *dcr_reg;
+
+	pm_cpu = of_get_property(node, "pm-cpu", &len);
+	if (pm_cpu && (len == sizeof(unsigned int)))
+		cpm->pm_cpu = *pm_cpu;
+
+	pm_off = of_get_property(node, "pm-off", &len);
+	if (pm_off && (len == sizeof(unsigned int)))
+		cpm->pm_off = *pm_off;
+
+	pm_doze = of_get_property(node, "pm-doze", &len);
+	if (pm_doze && (len == sizeof(unsigned int)))
+		cpm->pm_doze = *pm_doze;
+
+	pm_nap = of_get_property(node, "pm-nap", &len);
+	if (pm_nap && (len == sizeof(unsigned int)))
+		cpm->pm_nap = *pm_nap;
+
+	pm_deepsleep = of_get_property(node, "pm-deepsleep", &len);
+	if (pm_deepsleep && (len == sizeof(unsigned int)))
+		cpm->pm_deepsleep = *pm_deepsleep;
+
+	cpm_get_pm_iic(cpm, node);
+	cpm_get_pm_emac(cpm, node);
+
+	printk (KERN_INFO "CPM%d: DCR at 0x%x\n", cpm->index, cpm->dcrbase);
+
+	cpm->ready = 1;
+
+	mtdcr(cpm->dcrbase + CPM_ER, 
+		mfdcr(cpm->dcrbase + CPM_ER) | cpm->pm_off | cpm->pm_cpu);
+	mtdcr(cpm->dcrbase + CPM_FR,
+		mfdcr(cpm->dcrbase + CPM_FR) | cpm->pm_off);
+
+	/* put unused IP into sleep */
+	if (pcie_used == 0){
+		mtdcr(cpm->dcrbase + CPM_ER,
+			mfdcr(cpm->dcrbase + CPM_ER) | CPM_PCIE_SLEEP);
+		mtdcr(cpm->dcrbase + CPM_FR,
+			mfdcr(cpm->dcrbase + CPM_FR) | CPM_PCIE_SLEEP);
+	}
+	else if (pcie_used == 1){
+		mtdcr(cpm->dcrbase + CPM_ER,
+			mfdcr(cpm->dcrbase + CPM_ER) | CPM_SATA0_SLEEP);
+		mtdcr(cpm->dcrbase + CPM_FR,
+			mfdcr(cpm->dcrbase + CPM_FR) | CPM_SATA0_SLEEP);
+	}
+}
+
+
+static int __init cpm_pm_mem_init(void)
+{
+	struct cpm_pm_mem *mem;
+	phys_addr_t p;
+
+	mem = &cpm_pm_mem;
+
+	memset(mem,0,sizeof(struct cpm_pm_mem));
+
+	mem->suspend = ocm_alloc(&p,cpm_suspend_mem_size, CPM_PM_MEM_ALIGN,
+
+				OCM_NON_CACHED, "cpm_suspend_mem");
+	if (!mem->suspend) {
+		printk(KERN_ERR "CPM: failed to allocate suspend memory!\n");
+		return -ENOMEM;
+	}
+
+	mem->resume = ocm_alloc(&p,cpm_resume_mem_size, CPM_PM_MEM_ALIGN,
+				OCM_NON_CACHED, "cpm_resume_mem");
+	if (!mem->resume) {
+		printk(KERN_ERR "CPM: failed to allocate resume memory!\n");
+		ocm_free(mem->suspend);
+		mem->suspend = NULL;
+		return -ENOMEM;
+	}
+
+	mem->data = ocm_alloc(&p,CPM_PM_MEM_DATA_SIZE, CPM_PM_MEM_ALIGN,
+				OCM_NON_CACHED, "cpm_data_mem");
+	if (!mem->data) {
+		printk(KERN_ERR "CPM: failed to allocate data memory!\n");
+		ocm_free(mem->suspend);
+		ocm_free(mem->resume);
+		mem->suspend = NULL;
+		mem->resume = NULL;
+		return -ENOMEM;
+	}
+
+	printk(KERN_INFO "CPM: ocm suspend address 0x%p\n",mem->suspend);
+	printk(KERN_INFO "CPM: ocm resume address 0x%p\n",mem->resume);
+	printk(KERN_INFO "CPM: ocm data address 0x%p\n",mem->data);
+
+	memcpy(mem->suspend, cpm_suspend_mem, cpm_suspend_mem_size);
+	memcpy(mem->resume, cpm_resume_mem, cpm_resume_mem_size);
+	memset(mem->data,0,CPM_PM_MEM_DATA_SIZE);
+
+	return 0;
+}
+
+static int __init cpm_init(void)
+{
+	struct device_node *np;
+	int count;
+	const u32 *dcrreg;
+
+	count = 0;
+	for_each_compatible_node(np, NULL, "ibm,cpm") {
+		count++;
+	}
+// 	printk(KERN_ERR "CPM: cpm_init %d!\n", count);
+	if (!count) {
+		return 0;
+	}
+
+        cpm_nodes = kzalloc((count*sizeof(struct cpm)), GFP_KERNEL);
+        if (!cpm_nodes) {
+                printk(KERN_ERR "CPM: out of memory allocating CPM!\n");
+		return -ENOMEM;
+        }
+
+	cpm_count = count;
+
+	for_each_compatible_node(np, NULL, "ibm,cpm") {
+		cpm_init_node(np);
+	}
+	
+	cpm_pm_mem_init();
+
+//	cpm_proc_init();
+
+	np = of_find_compatible_node(NULL, NULL, "ibm,l2-cache");
+	if (!np) {
+		printk(KERN_ERR "Can't get l2-cache node\n");
+		return 0;
+	}
+
+	dcrreg = of_get_property(np, "dcr-reg", &count);
+	if (!dcrreg || (count != 4 * sizeof(u32))) {
+		printk(KERN_ERR "%s: Can't get DCR register base !",
+		       np->full_name);
+		of_node_put(np);
+		return -ENODEV;
+	}
+	dcrbase_l2c = dcrreg[2];
+
+	return 0;
+}
+
+subsys_initcall(cpm_init);