[linux-block.git] / arch / frv / kernel / pm.c

/*
 * FR-V Power Management Routines
 *
 * Copyright (c) 2004 Red Hat, Inc.
 *
 * Based on SA1100 version:
 * Copyright (c) 2001 Cliff Brake <cbrake@accelent.com>
 *
 * 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/pm.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/sysctl.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <asm/uaccess.h>

#include <asm/mb86943a.h>

#include "local.h"

/*
 * Debug macros
 */
#define DEBUG

int pm_do_suspend(void)
{
	local_irq_disable();

	__set_LEDS(0xb1);

	/* go zzz */
	frv_cpu_suspend(pdm_suspend_mode);

	__set_LEDS(0xb2);

	local_irq_enable();

	return 0;
}

static unsigned long __irq_mask;

/*
 * Setup interrupt masks, etc to enable wakeup by power switch
 */
static void __default_power_switch_setup(void)
{
	/* default is to mask all interrupt sources. */
	__irq_mask = *(unsigned long *)0xfeff9820;
	*(unsigned long *)0xfeff9820 = 0xfffe0000;
}

/*
 * Cleanup interrupt masks, etc after wakeup by power switch
 */
static void __default_power_switch_cleanup(void)
{
	*(unsigned long *)0xfeff9820 = __irq_mask;
}

/*
 * Return non-zero if wakeup irq was caused by power switch
 */
static int __default_power_switch_check(void)
{
	return 1;
}

void (*__power_switch_wake_setup)(void) = __default_power_switch_setup;
int  (*__power_switch_wake_check)(void) = __default_power_switch_check;
void (*__power_switch_wake_cleanup)(void) = __default_power_switch_cleanup;

int pm_do_bus_sleep(void)
{
	local_irq_disable();

	/*
         * Here is where we need some platform-dependent setup
	 * of the interrupt state so that appropriate wakeup
	 * sources are allowed and all others are masked.
	 */
	__power_switch_wake_setup();

	__set_LEDS(0xa1);

	/* go zzz
	 *
	 * This is in a loop in case power switch shares an irq with other
	 * devices. The wake_check() tells us if we need to finish waking
	 * or go back to sleep.
	 */
	do {
		frv_cpu_suspend(HSR0_PDM_BUS_SLEEP);
	} while (__power_switch_wake_check && !__power_switch_wake_check());

	__set_LEDS(0xa2);

	/*
         * Here is where we need some platform-dependent restore
	 * of the interrupt state prior to being called.
	 */
	__power_switch_wake_cleanup();

	local_irq_enable();

	return 0;
}

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

#ifdef CONFIG_SYSCTL
/*
 * Use a temporary sysctl number. Horrid, but will be cleaned up in 2.6
 * when all the PM interfaces exist nicely.
 */
#define CTL_PM_SUSPEND 1
#define CTL_PM_CMODE 2
#define CTL_PM_P0 4
#define CTL_PM_CM 5

static int user_atoi(char __user *ubuf, size_t len)
{
	char buf[16];
	unsigned long ret;

	if (len > 15)
		return -EINVAL;

	if (copy_from_user(buf, ubuf, len))
		return -EFAULT;

	buf[len] = 0;
	ret = simple_strtoul(buf, NULL, 0);
	if (ret > INT_MAX)
		return -ERANGE;
	return ret;
}

/*
 * Send us to sleep.
 */
static int sysctl_pm_do_suspend(ctl_table *ctl, int write,
				void __user *buffer, size_t *lenp, loff_t *fpos)
{
	int retval, mode;

	if (*lenp <= 0)
		return -EIO;

	mode = user_atoi(buffer, *lenp);
	if ((mode != 1) && (mode != 5))
		return -EINVAL;

	if (retval == 0) {
		if (mode == 5)
		    retval = pm_do_bus_sleep();
		else
		    retval = pm_do_suspend();
	}

	return retval;
}

static int try_set_cmode(int new_cmode)
{
	if (new_cmode > 15)
		return -EINVAL;
	if (!(clock_cmodes_permitted & (1<<new_cmode)))
		return -EINVAL;

	/* now change cmode */
	local_irq_disable();
	frv_dma_pause_all();

	frv_change_cmode(new_cmode);

	determine_clocks(0);
	time_divisor_init();

#ifdef DEBUG
	determine_clocks(1);
#endif
	frv_dma_resume_all();
	local_irq_enable();

	return 0;
}


static int cmode_procctl(ctl_table *ctl, int write,
			 void __user *buffer, size_t *lenp, loff_t *fpos)
{
	int new_cmode;

	if (!write)
		return proc_dointvec(ctl, write, buffer, lenp, fpos);

	new_cmode = user_atoi(buffer, *lenp);

	return try_set_cmode(new_cmode)?:*lenp;
}

static int cmode_sysctl(ctl_table *table,
			void __user *oldval, size_t __user *oldlenp,
			void __user *newval, size_t newlen)
{
	if (oldval && oldlenp) {
		size_t oldlen;

		if (get_user(oldlen, oldlenp))
			return -EFAULT;

		if (oldlen != sizeof(int))
			return -EINVAL;

		if (put_user(clock_cmode_current, (unsigned __user *)oldval) ||
		    put_user(sizeof(int), oldlenp))
			return -EFAULT;
	}
	if (newval && newlen) {
		int new_cmode;

		if (newlen != sizeof(int))
			return -EINVAL;

		if (get_user(new_cmode, (int __user *)newval))
			return -EFAULT;

		return try_set_cmode(new_cmode)?:1;
	}
	return 1;
}

static int try_set_p0(int new_p0)
{
	unsigned long flags, clkc;

	if (new_p0 < 0 || new_p0 > 1)
		return -EINVAL;

	local_irq_save(flags);
	__set_PSR(flags & ~PSR_ET);

	frv_dma_pause_all();

	clkc = __get_CLKC();
	if (new_p0)
		clkc |= CLKC_P0;
	else
		clkc &= ~CLKC_P0;
	__set_CLKC(clkc);

	determine_clocks(0);
	time_divisor_init();

#ifdef DEBUG
	determine_clocks(1);
#endif
	frv_dma_resume_all();
	local_irq_restore(flags);
	return 0;
}

static int try_set_cm(int new_cm)
{
	unsigned long flags, clkc;

	if (new_cm < 0 || new_cm > 1)
		return -EINVAL;

	local_irq_save(flags);
	__set_PSR(flags & ~PSR_ET);

	frv_dma_pause_all();

	clkc = __get_CLKC();
	clkc &= ~CLKC_CM;
	clkc |= new_cm;
	__set_CLKC(clkc);

	determine_clocks(0);
	time_divisor_init();

#if 1 //def DEBUG
	determine_clocks(1);
#endif

	frv_dma_resume_all();
	local_irq_restore(flags);
	return 0;
}

static int p0_procctl(ctl_table *ctl, int write,
		      void __user *buffer, size_t *lenp, loff_t *fpos)
{
	int new_p0;

	if (!write)
		return proc_dointvec(ctl, write, buffer, lenp, fpos);

	new_p0 = user_atoi(buffer, *lenp);

	return try_set_p0(new_p0)?:*lenp;
}

static int p0_sysctl(ctl_table *table,
		     void __user *oldval, size_t __user *oldlenp,
		     void __user *newval, size_t newlen)
{
	if (oldval && oldlenp) {
		size_t oldlen;

		if (get_user(oldlen, oldlenp))
			return -EFAULT;

		if (oldlen != sizeof(int))
			return -EINVAL;

		if (put_user(clock_p0_current, (unsigned __user *)oldval) ||
		    put_user(sizeof(int), oldlenp))
			return -EFAULT;
	}
	if (newval && newlen) {
		int new_p0;

		if (newlen != sizeof(int))
			return -EINVAL;

		if (get_user(new_p0, (int __user *)newval))
			return -EFAULT;

		return try_set_p0(new_p0)?:1;
	}
	return 1;
}

static int cm_procctl(ctl_table *ctl, int write,
		      void __user *buffer, size_t *lenp, loff_t *fpos)
{
	int new_cm;

	if (!write)
		return proc_dointvec(ctl, write, buffer, lenp, fpos);

	new_cm = user_atoi(buffer, *lenp);

	return try_set_cm(new_cm)?:*lenp;
}

static int cm_sysctl(ctl_table *table,
		     void __user *oldval, size_t __user *oldlenp,
		     void __user *newval, size_t newlen)
{
	if (oldval && oldlenp) {
		size_t oldlen;

		if (get_user(oldlen, oldlenp))
			return -EFAULT;

		if (oldlen != sizeof(int))
			return -EINVAL;

		if (put_user(clock_cm_current, (unsigned __user *)oldval) ||
		    put_user(sizeof(int), oldlenp))
			return -EFAULT;
	}
	if (newval && newlen) {
		int new_cm;

		if (newlen != sizeof(int))
			return -EINVAL;

		if (get_user(new_cm, (int __user *)newval))
			return -EFAULT;

		return try_set_cm(new_cm)?:1;
	}
	return 1;
}


static struct ctl_table pm_table[] =
{
	{
		.ctl_name	= CTL_PM_SUSPEND,
		.procname	= "suspend",
		.data		= NULL,
		.maxlen		= 0,
		.mode		= 0200,
		.proc_handler	= &sysctl_pm_do_suspend,
	},
	{
		.ctl_name	= CTL_PM_CMODE,
		.procname	= "cmode",
		.data		= &clock_cmode_current,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &cmode_procctl,
		.strategy	= &cmode_sysctl,
	},
	{
		.ctl_name	= CTL_PM_P0,
		.procname	= "p0",
		.data		= &clock_p0_current,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &p0_procctl,
		.strategy	= &p0_sysctl,
	},
	{
		.ctl_name	= CTL_PM_CM,
		.procname	= "cm",
		.data		= &clock_cm_current,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &cm_procctl,
		.strategy	= &cm_sysctl,
	},
	{ .ctl_name = 0}
};

static struct ctl_table pm_dir_table[] =
{
	{
		.ctl_name	= CTL_PM,
		.procname	= "pm",
		.mode		= 0555,
		.child		= pm_table,
	},
	{ .ctl_name = 0}
};

/*
 * Initialize power interface
 */
static int __init pm_init(void)
{
	register_sysctl_table(pm_dir_table);
	return 0;
}

__initcall(pm_init);

#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* FR-V Power Management Routines
	3	*
	4	* Copyright (c) 2004 Red Hat, Inc.
	5	*
	6	* Based on SA1100 version:
	7	* Copyright (c) 2001 Cliff Brake <cbrake@accelent.com>
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License.
	11	*
	12	*/
	13
1da177e4	14	#include <linux/init.h>
40234401	15	#include <linux/module.h>
1da177e4 LT	16	#include <linux/pm.h>
	17	#include <linux/sched.h>
	18	#include <linux/interrupt.h>
	19	#include <linux/sysctl.h>
	20	#include <linux/errno.h>
	21	#include <linux/delay.h>
	22	#include <asm/uaccess.h>
	23
	24	#include <asm/mb86943a.h>
	25
	26	#include "local.h"
	27
1da177e4 LT	28	/*
	29	* Debug macros
	30	*/
	31	#define DEBUG
	32
	33	int pm_do_suspend(void)
	34	{
	35	local_irq_disable();
	36
	37	__set_LEDS(0xb1);
	38
	39	/* go zzz */
	40	frv_cpu_suspend(pdm_suspend_mode);
	41
	42	__set_LEDS(0xb2);
	43
	44	local_irq_enable();
	45
	46	return 0;
	47	}
	48
	49	static unsigned long __irq_mask;
	50
	51	/*
	52	* Setup interrupt masks, etc to enable wakeup by power switch
	53	*/
	54	static void __default_power_switch_setup(void)
	55	{
	56	/* default is to mask all interrupt sources. */
	57	__irq_mask = (unsigned long )0xfeff9820;
	58	(unsigned long )0xfeff9820 = 0xfffe0000;
	59	}
	60
	61	/*
	62	* Cleanup interrupt masks, etc after wakeup by power switch
	63	*/
	64	static void __default_power_switch_cleanup(void)
	65	{
	66	(unsigned long )0xfeff9820 = __irq_mask;
	67	}
	68
	69	/*
	70	* Return non-zero if wakeup irq was caused by power switch
	71	*/
	72	static int __default_power_switch_check(void)
	73	{
	74	return 1;
	75	}
	76
	77	void (*__power_switch_wake_setup)(void) = __default_power_switch_setup;
	78	int (*__power_switch_wake_check)(void) = __default_power_switch_check;
	79	void (*__power_switch_wake_cleanup)(void) = __default_power_switch_cleanup;
	80
	81	int pm_do_bus_sleep(void)
	82	{
	83	local_irq_disable();
	84
	85	/*
	86	* Here is where we need some platform-dependent setup
	87	* of the interrupt state so that appropriate wakeup
	88	* sources are allowed and all others are masked.
	89	*/
	90	__power_switch_wake_setup();
	91
92	__set_LEDS(0xa1);
93
94	/* go zzz
95	*
96	* This is in a loop in case power switch shares an irq with other
97	* devices. The wake_check() tells us if we need to finish waking
98	* or go back to sleep.
99	*/
100	do {
101	frv_cpu_suspend(HSR0_PDM_BUS_SLEEP);
102	} while (__power_switch_wake_check && !__power_switch_wake_check());
103
104	__set_LEDS(0xa2);
105
106	/*
107	* Here is where we need some platform-dependent restore
108	* of the interrupt state prior to being called.
109	*/
110	__power_switch_wake_cleanup();
111
112	local_irq_enable();
113
114	return 0;
115	}
116
117	unsigned long sleep_phys_sp(void *sp)
118	{
119	return virt_to_phys(sp);
120	}
121
122	#ifdef CONFIG_SYSCTL
123	/*
124	* Use a temporary sysctl number. Horrid, but will be cleaned up in 2.6
125	* when all the PM interfaces exist nicely.
126	*/
1da177e4 LT	127	#define CTL_PM_SUSPEND 1
	128	#define CTL_PM_CMODE 2
	129	#define CTL_PM_P0 4
	130	#define CTL_PM_CM 5
	131
7ab76d72	132	static int user_atoi(char __user *ubuf, size_t len)
1da177e4 LT	133	{
	134	char buf[16];
	135	unsigned long ret;
	136
	137	if (len > 15)
	138	return -EINVAL;
	139
	140	if (copy_from_user(buf, ubuf, len))
	141	return -EFAULT;
	142
	143	buf[len] = 0;
	144	ret = simple_strtoul(buf, NULL, 0);
	145	if (ret > INT_MAX)
	146	return -ERANGE;
	147	return ret;
	148	}
	149
	150	/*
	151	* Send us to sleep.
	152	*/
8d65af78	153	static int sysctl_pm_do_suspend(ctl_table *ctl, int write,
7ab76d72	154	void __user buffer, size_t lenp, loff_t *fpos)
1da177e4 LT	155	{
	156	int retval, mode;
	157
	158	if (*lenp <= 0)
	159	return -EIO;
	160
	161	mode = user_atoi(buffer, *lenp);
	162	if ((mode != 1) && (mode != 5))
	163	return -EINVAL;
	164
1da177e4 LT	165	if (retval == 0) {
	166	if (mode == 5)
	167	retval = pm_do_bus_sleep();
	168	else
	169	retval = pm_do_suspend();
1da177e4 LT	170	}
	171
	172	return retval;
	173	}
	174
	175	static int try_set_cmode(int new_cmode)
	176	{
	177	if (new_cmode > 15)
	178	return -EINVAL;
	179	if (!(clock_cmodes_permitted & (1<<new_cmode)))
	180	return -EINVAL;
	181
1da177e4 LT	182	/* now change cmode */
	183	local_irq_disable();
	184	frv_dma_pause_all();
	185
	186	frv_change_cmode(new_cmode);
	187
	188	determine_clocks(0);
	189	time_divisor_init();
	190
	191	#ifdef DEBUG
	192	determine_clocks(1);
	193	#endif
	194	frv_dma_resume_all();
	195	local_irq_enable();
	196
1da177e4 LT	197	return 0;
	198	}
	199
	200
8d65af78	201	static int cmode_procctl(ctl_table *ctl, int write,
7ab76d72	202	void __user buffer, size_t lenp, loff_t *fpos)
1da177e4 LT	203	{
	204	int new_cmode;
	205
	206	if (!write)
8d65af78	207	return proc_dointvec(ctl, write, buffer, lenp, fpos);
1da177e4 LT	208
	209	new_cmode = user_atoi(buffer, *lenp);
	210
	211	return try_set_cmode(new_cmode)?:*lenp;
	212	}
	213
f221e726	214	static int cmode_sysctl(ctl_table *table,
7ab76d72	215	void __user oldval, size_t __user oldlenp,
1f29bcd7	216	void __user *newval, size_t newlen)
1da177e4 LT	217	{
	218	if (oldval && oldlenp) {
	219	size_t oldlen;
	220
	221	if (get_user(oldlen, oldlenp))
	222	return -EFAULT;
	223
	224	if (oldlen != sizeof(int))
	225	return -EINVAL;
	226
7ab76d72	227	if (put_user(clock_cmode_current, (unsigned __user *)oldval) \|\|
1da177e4 LT	228	put_user(sizeof(int), oldlenp))
	229	return -EFAULT;
	230	}
	231	if (newval && newlen) {
	232	int new_cmode;
	233
	234	if (newlen != sizeof(int))
	235	return -EINVAL;
	236
7ab76d72	237	if (get_user(new_cmode, (int __user *)newval))
1da177e4 LT	238	return -EFAULT;
	239
	240	return try_set_cmode(new_cmode)?:1;
	241	}
	242	return 1;
	243	}
	244
	245	static int try_set_p0(int new_p0)
	246	{
	247	unsigned long flags, clkc;
	248
	249	if (new_p0 < 0 \|\| new_p0 > 1)
	250	return -EINVAL;
	251
	252	local_irq_save(flags);
	253	__set_PSR(flags & ~PSR_ET);
	254
	255	frv_dma_pause_all();
	256
	257	clkc = __get_CLKC();
	258	if (new_p0)
	259	clkc \|= CLKC_P0;
	260	else
	261	clkc &= ~CLKC_P0;
	262	__set_CLKC(clkc);
	263
	264	determine_clocks(0);
	265	time_divisor_init();
	266
	267	#ifdef DEBUG
	268	determine_clocks(1);
	269	#endif
	270	frv_dma_resume_all();
	271	local_irq_restore(flags);
	272	return 0;
	273	}
	274
	275	static int try_set_cm(int new_cm)
	276	{
	277	unsigned long flags, clkc;
	278
	279	if (new_cm < 0 \|\| new_cm > 1)
	280	return -EINVAL;
	281
	282	local_irq_save(flags);
	283	__set_PSR(flags & ~PSR_ET);
	284
	285	frv_dma_pause_all();
	286
	287	clkc = __get_CLKC();
	288	clkc &= ~CLKC_CM;
	289	clkc \|= new_cm;
	290	__set_CLKC(clkc);
	291
	292	determine_clocks(0);
	293	time_divisor_init();
	294
	295	#if 1 //def DEBUG
	296	determine_clocks(1);
	297	#endif
	298
	299	frv_dma_resume_all();
	300	local_irq_restore(flags);
	301	return 0;
302	}
303
8d65af78	304	static int p0_procctl(ctl_table *ctl, int write,
7ab76d72	305	void __user buffer, size_t lenp, loff_t *fpos)
1da177e4 LT	306	{
	307	int new_p0;
	308
	309	if (!write)
8d65af78	310	return proc_dointvec(ctl, write, buffer, lenp, fpos);
1da177e4 LT	311
	312	new_p0 = user_atoi(buffer, *lenp);
	313
	314	return try_set_p0(new_p0)?:*lenp;
	315	}
	316
f221e726	317	static int p0_sysctl(ctl_table *table,
7ab76d72	318	void __user oldval, size_t __user oldlenp,
1f29bcd7	319	void __user *newval, size_t newlen)
1da177e4 LT	320	{
	321	if (oldval && oldlenp) {
	322	size_t oldlen;
	323
	324	if (get_user(oldlen, oldlenp))
	325	return -EFAULT;
	326
	327	if (oldlen != sizeof(int))
	328	return -EINVAL;
	329
7ab76d72	330	if (put_user(clock_p0_current, (unsigned __user *)oldval) \|\|
1da177e4 LT	331	put_user(sizeof(int), oldlenp))
	332	return -EFAULT;
	333	}
	334	if (newval && newlen) {
	335	int new_p0;
	336
	337	if (newlen != sizeof(int))
	338	return -EINVAL;
	339
7ab76d72	340	if (get_user(new_p0, (int __user *)newval))
1da177e4 LT	341	return -EFAULT;
	342
	343	return try_set_p0(new_p0)?:1;
	344	}
	345	return 1;
	346	}
	347
8d65af78	348	static int cm_procctl(ctl_table *ctl, int write,
7ab76d72	349	void __user buffer, size_t lenp, loff_t *fpos)
1da177e4 LT	350	{
	351	int new_cm;
	352
	353	if (!write)
8d65af78	354	return proc_dointvec(ctl, write, buffer, lenp, fpos);
1da177e4 LT	355
	356	new_cm = user_atoi(buffer, *lenp);
	357
	358	return try_set_cm(new_cm)?:*lenp;
	359	}
	360
f221e726	361	static int cm_sysctl(ctl_table *table,
7ab76d72	362	void __user oldval, size_t __user oldlenp,
1f29bcd7	363	void __user *newval, size_t newlen)
1da177e4 LT	364	{
	365	if (oldval && oldlenp) {
	366	size_t oldlen;
	367
	368	if (get_user(oldlen, oldlenp))
	369	return -EFAULT;
	370
	371	if (oldlen != sizeof(int))
	372	return -EINVAL;
	373
7ab76d72	374	if (put_user(clock_cm_current, (unsigned __user *)oldval) \|\|
1da177e4 LT	375	put_user(sizeof(int), oldlenp))
	376	return -EFAULT;
	377	}
	378	if (newval && newlen) {
	379	int new_cm;
	380
	381	if (newlen != sizeof(int))
	382	return -EINVAL;
	383
7ab76d72	384	if (get_user(new_cm, (int __user *)newval))
1da177e4 LT	385	return -EFAULT;
	386
	387	return try_set_cm(new_cm)?:1;
	388	}
	389	return 1;
	390	}
	391
	392
	393	static struct ctl_table pm_table[] =
	394	{
dfd007a6 EB	395	{
	396	.ctl_name = CTL_PM_SUSPEND,
	397	.procname = "suspend",
	398	.data = NULL,
	399	.maxlen = 0,
	400	.mode = 0200,
	401	.proc_handler = &sysctl_pm_do_suspend,
	402	},
	403	{
	404	.ctl_name = CTL_PM_CMODE,
	405	.procname = "cmode",
	406	.data = &clock_cmode_current,
	407	.maxlen = sizeof(int),
	408	.mode = 0644,
	409	.proc_handler = &cmode_procctl,
	410	.strategy = &cmode_sysctl,
	411	},
	412	{
	413	.ctl_name = CTL_PM_P0,
	414	.procname = "p0",
	415	.data = &clock_p0_current,
	416	.maxlen = sizeof(int),
	417	.mode = 0644,
	418	.proc_handler = &p0_procctl,
	419	.strategy = &p0_sysctl,
	420	},
	421	{
	422	.ctl_name = CTL_PM_CM,
	423	.procname = "cm",
	424	.data = &clock_cm_current,
	425	.maxlen = sizeof(int),
	426	.mode = 0644,
	427	.proc_handler = &cm_procctl,
	428	.strategy = &cm_sysctl,
	429	},
	430	{ .ctl_name = 0}
1da177e4 LT	431	};
	432
	433	static struct ctl_table pm_dir_table[] =
	434	{
dfd007a6 EB	435	{
	436	.ctl_name = CTL_PM,
	437	.procname = "pm",
	438	.mode = 0555,
	439	.child = pm_table,
	440	},
	441	{ .ctl_name = 0}
1da177e4 LT	442	};
	443
	444	/*
	445	* Initialize power interface
	446	*/
	447	static int __init pm_init(void)
	448	{
0b4d4147	449	register_sysctl_table(pm_dir_table);
1da177e4 LT	450	return 0;
	451	}
	452
	453	__initcall(pm_init);
	454
	455	#endif