[deliverable/linux.git] / arch / arm / mach-pxa / pm.c

/*
 * PXA250/210 Power Management Routines
 *
 * Original code for the SA11x0:
 * Copyright (c) 2001 Cliff Brake <cbrake@accelent.com>
 *
 * Modified for the PXA250 by Nicolas Pitre:
 * Copyright (c) 2002 Monta Vista Software, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License.
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/suspend.h>
#include <linux/errno.h>
#include <linux/time.h>

#include <asm/hardware.h>
#include <asm/memory.h>
#include <asm/system.h>
#include <asm/arch/pm.h>
#include <asm/arch/pxa-regs.h>
#include <asm/arch/lubbock.h>
#include <asm/mach/time.h>

struct pxa_cpu_pm_fns *pxa_cpu_pm_fns;
static unsigned long *sleep_save;

int pxa_pm_enter(suspend_state_t state)
{
	unsigned long sleep_save_checksum = 0, checksum = 0;
	int i;

#ifdef CONFIG_IWMMXT
	/* force any iWMMXt context to ram **/
	if (elf_hwcap & HWCAP_IWMMXT)
		iwmmxt_task_disable(NULL);
#endif

	pxa_cpu_pm_fns->save(sleep_save);

	/* Clear sleep reset status */
	RCSR = RCSR_SMR;

	/* before sleeping, calculate and save a checksum */
	for (i = 0; i < pxa_cpu_pm_fns->save_size - 1; i++)
		sleep_save_checksum += sleep_save[i];

	/* *** go zzz *** */
	pxa_cpu_pm_fns->enter(state);
	cpu_init();

	/* after sleeping, validate the checksum */
	for (i = 0; i < pxa_cpu_pm_fns->save_size - 1; i++)
		checksum += sleep_save[i];

	/* if invalid, display message and wait for a hardware reset */
	if (checksum != sleep_save_checksum) {
#ifdef CONFIG_ARCH_LUBBOCK
		LUB_HEXLED = 0xbadbadc5;
#endif
		while (1)
			pxa_cpu_pm_fns->enter(state);
	}

	pxa_cpu_pm_fns->restore(sleep_save);

	pr_debug("*** made it back from resume\n");

	return 0;
}

EXPORT_SYMBOL_GPL(pxa_pm_enter);

unsigned long sleep_phys_sp(void *sp)
{
	return virt_to_phys(sp);
}

static int pxa_pm_valid(suspend_state_t state)
{
	if (pxa_cpu_pm_fns)
		return pxa_cpu_pm_fns->valid(state);

	return -EINVAL;
}

static struct platform_suspend_ops pxa_pm_ops = {
	.valid		= pxa_pm_valid,
	.enter		= pxa_pm_enter,
};

static int __init pxa_pm_init(void)
{
	if (!pxa_cpu_pm_fns) {
		printk(KERN_ERR "no valid pxa_cpu_pm_fns defined\n");
		return -EINVAL;
	}

	sleep_save = kmalloc(pxa_cpu_pm_fns->save_size, GFP_KERNEL);
	if (!sleep_save) {
		printk(KERN_ERR "failed to alloc memory for pm save\n");
		return -ENOMEM;
	}

	suspend_set_ops(&pxa_pm_ops);
	return 0;
}

device_initcall(pxa_pm_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* PXA250/210 Power Management Routines
	3	*
	4	* Original code for the SA11x0:
	5	* Copyright (c) 2001 Cliff Brake <cbrake@accelent.com>
	6	*
	7	* Modified for the PXA250 by Nicolas Pitre:
	8	* Copyright (c) 2002 Monta Vista Software, Inc.
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License.
	12	*/
1da177e4	13	#include <linux/init.h>
756c7b74	14	#include <linux/module.h>
1da177e4 LT	15	#include <linux/suspend.h>
	16	#include <linux/errno.h>
	17	#include <linux/time.h>
	18
	19	#include <asm/hardware.h>
	20	#include <asm/memory.h>
	21	#include <asm/system.h>
756c7b74	22	#include <asm/arch/pm.h>
1da177e4 LT	23	#include <asm/arch/pxa-regs.h>
	24	#include <asm/arch/lubbock.h>
	25	#include <asm/mach/time.h>
	26
711be5cc EM	27	struct pxa_cpu_pm_fns *pxa_cpu_pm_fns;
711be5cc EM	28	static unsigned long *sleep_save;
1da177e4	29
756c7b74	30	int pxa_pm_enter(suspend_state_t state)
1da177e4	31	{
711be5cc	32	unsigned long sleep_save_checksum = 0, checksum = 0;
1da177e4	33	int i;
1da177e4 LT	34
	35	#ifdef CONFIG_IWMMXT
	36	/* force any iWMMXt context to ram **/
afe4b25e LB	37	if (elf_hwcap & HWCAP_IWMMXT)
afe4b25e LB	38	iwmmxt_task_disable(NULL);
1da177e4 LT	39	#endif
1da177e4 LT	40
711be5cc	41	pxa_cpu_pm_fns->save(sleep_save);
1da177e4 LT	42
	43	/* Clear sleep reset status */
	44	RCSR = RCSR_SMR;
	45
1da177e4	46	/* before sleeping, calculate and save a checksum */
711be5cc EM	47	for (i = 0; i < pxa_cpu_pm_fns->save_size - 1; i++)
711be5cc EM	48	sleep_save_checksum += sleep_save[i];
1da177e4 LT	49
1da177e4 LT	50	/* * go zzz * */
711be5cc	51	pxa_cpu_pm_fns->enter(state);
36c5ed23 RK	52	cpu_init();
36c5ed23 RK	53
1da177e4	54	/* after sleeping, validate the checksum */
711be5cc	55	for (i = 0; i < pxa_cpu_pm_fns->save_size - 1; i++)
1da177e4 LT	56	checksum += sleep_save[i];
	57
	58	/* if invalid, display message and wait for a hardware reset */
711be5cc	59	if (checksum != sleep_save_checksum) {
1da177e4 LT	60	#ifdef CONFIG_ARCH_LUBBOCK
	61	LUB_HEXLED = 0xbadbadc5;
	62	#endif
	63	while (1)
711be5cc	64	pxa_cpu_pm_fns->enter(state);
1da177e4 LT	65	}
1da177e4 LT	66
711be5cc	67	pxa_cpu_pm_fns->restore(sleep_save);
1da177e4	68
711be5cc	69	pr_debug("*** made it back from resume\n");
1da177e4 LT	70
	71	return 0;
	72	}
	73
756c7b74 RP	74	EXPORT_SYMBOL_GPL(pxa_pm_enter);
756c7b74 RP	75
1da177e4 LT	76	unsigned long sleep_phys_sp(void *sp)
	77	{
	78	return virt_to_phys(sp);
	79	}
711be5cc EM	80
	81	static int pxa_pm_valid(suspend_state_t state)
	82	{
	83	if (pxa_cpu_pm_fns)
	84	return pxa_cpu_pm_fns->valid(state);
	85
	86	return -EINVAL;
	87	}
	88
26398a70	89	static struct platform_suspend_ops pxa_pm_ops = {
711be5cc EM	90	.valid = pxa_pm_valid,
	91	.enter = pxa_pm_enter,
	92	};
	93
	94	static int __init pxa_pm_init(void)
	95	{
	96	if (!pxa_cpu_pm_fns) {
	97	printk(KERN_ERR "no valid pxa_cpu_pm_fns defined\n");
	98	return -EINVAL;
	99	}
	100
	101	sleep_save = kmalloc(pxa_cpu_pm_fns->save_size, GFP_KERNEL);
	102	if (!sleep_save) {
	103	printk(KERN_ERR "failed to alloc memory for pm save\n");
	104	return -ENOMEM;
	105	}
	106
26398a70	107	suspend_set_ops(&pxa_pm_ops);
711be5cc EM	108	return 0;
	109	}
	110
	111	device_initcall(pxa_pm_init);