+OP_PARAM_ATTR(1);+OP_PARAM_ATTR(2);+OP_PARAM_ATTR(3);+OP_PARAM_ATTR(4);+OP_PARAM_ATTR(5);+OP_PARAM_ATTR(6);+OP_PARAM_ATTR(7);+OP_PARAM_ATTR(8);+OP_PARAM_ATTR(9);+OP_PARAM_ATTR(10);+OP_PARAM_ATTR(11);+OP_PARAM_ATTR(12);+OP_PARAM_ATTR(13);+OP_PARAM_ATTR(14);+OP_PARAM_ATTR(15);+OP_PARAM_ATTR(16);+OP_PARAM_ATTR(17);+OP_PARAM_ATTR(18);+OP_PARAM_ATTR(19);++static struct dpm_op_attribute *op_param_attr[MAX_OP_PARAMS] = {+	&op_param0_attr,+	&op_param1_attr,+	&op_param2_attr,+	&op_param3_attr,+	&op_param4_attr,+	&op_param5_attr,+	&op_param6_attr,+	&op_param7_attr,+	&op_param8_attr,+	&op_param9_attr,+	&op_param10_attr,+	&op_param11_attr,+	&op_param12_attr,+	&op_param13_attr,+	&op_param14_attr,+	&op_param15_attr,+	&op_param16_attr,+	&op_param17_attr,+	&op_param18_attr,+	&op_param19_attr,+};++static ssize_t+op_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)+{+	struct dpm_op_attribute * op_attr = to_op_attr(attr);+	ssize_t ret = 0;++	if (op_attr->show)+		ret = op_attr->show(kobj,buf);+	return ret;+}++static ssize_t+op_attr_store(struct kobject * kobj, struct attribute * attr,+	      const char * buf, size_t count)+{+	struct dpm_op_attribute * op_attr = to_op_attr(attr);+	ssize_t ret = 0;++	if (op_attr->store)+		ret = op_attr->store(kobj,buf,count);+	return ret;+}++static struct sysfs_ops op_sysfs_ops = {+	.show	= op_attr_show,+	.store	= op_attr_store,+};++static struct attribute * op_default_attrs[] = {+	&an_op_control_attr.attr,+	&op_force_attr.attr,+	NULL,+};++static struct kobj_type ktype_op = {+	.release        = dpm_kobj_release,+	.sysfs_ops	= &op_sysfs_ops,+	.default_attrs	= op_default_attrs,+};++void dpm_sysfs_new_op(struct dpm_opt *opt)+{+	int i;++	memset(&opt->kobj, 0, sizeof(struct kobject));+	opt->kobj.kset = &dpm_subsys.kset,+	kobject_set_name(&opt->kobj,opt->name);+	opt->kobj.parent = &dpm_op_kobj;+	opt->kobj.ktype = &ktype_op;+	kobject_register(&opt->kobj);++	for (i = 0; (i < DPM_PP_NBR) && (i < MAX_OP_PARAMS); i++) {+		op_param_attr[i]->attr.name = dpm_param_names[i];+		sysfs_create_file(&opt->kobj, &op_param_attr[i]->attr);+	}++	return;+}++void dpm_sysfs_destroy_op(struct dpm_opt *opt)+{+	kobject_unregister(&opt->kobj);+	return;+}+++/*+ * state+ */+++static ssize_t state_control_show(struct subsystem * subsys, char * buf)+{+	ssize_t len = 0;+	int i;++	len += sprintf(buf + len, "states: ");++	for (i = 0; i < DPM_STATES; i++) {+		len += sprintf(buf + len, "%s ", dpm_state_names[i]);+	}++	len += sprintf(buf + len, "\ntask-states: min=%s norm=%s max=%s\n",+		       dpm_state_names[DPM_TASK_STATE - DPM_TASK_STATE_LIMIT],+		       dpm_state_names[DPM_TASK_STATE],+		       dpm_state_names[DPM_TASK_STATE + DPM_TASK_STATE_LIMIT]);++	return len;+}++static ssize_t state_control_store(struct subsystem * subsys, const char * buf,+				   size_t n)+{+	return -EINVAL;+}++static ssize_t active_state_show(struct subsystem * subsys, char * buf)+{+	unsigned long flags;+	ssize_t len = 0;++	if (dpm_lock_interruptible())+		return -ERESTARTSYS;++	if (!dpm_enabled || (dpm_active_state == DPM_NO_STATE)) {+		len += sprintf(buf + len, "[none]\n");+	} else {+		spin_lock_irqsave(&dpm_policy_lock, flags);+		len += sprintf(buf + len,"%s\n",+			       dpm_state_names[dpm_active_state]);+		spin_unlock_irqrestore(&dpm_policy_lock, flags);+	}++	dpm_unlock();+	return len;+}++static ssize_t active_state_store(struct subsystem * subsys, const char * buf,+				  size_t n)+{+	int error = 0;+	char *tbuf = NULL;+	char *token[MAXTOKENS];+	int ntoks = tokenizer(&tbuf, buf, n, (char **) &token, MAXTOKENS);++	if (ntoks <= 0) {+		error = ntoks;+		goto out;+	}++	error = dpm_set_op_state(token[0]);++ out:+	if (tbuf)+		kfree(tbuf);+        return error ? error : n;+}++#ifdef CONFIG_DPM_STATS+static ssize_t state_stats_show(struct subsystem * subsys, char * buf)+{+	unsigned long flags;+	ssize_t len = 0;+	int i;++	spin_lock_irqsave(&dpm_policy_lock, flags);++	for (i = 0; i < DPM_STATES; i++) {+		unsigned long long total_time = dpm_state_stats[i].total_time;++		if (i == dpm_active_state)+			total_time += (unsigned long long) dpm_time() -+				dpm_state_stats[i].start_time;++		len += sprintf(buf + len, "state: %s", dpm_state_names[i]);+                len += sprintf(buf + len, " ticks: %Lu",+			       (unsigned long long) dpm_time_to_usec(total_time));+		len += sprintf(buf + len, " times: %lu\n",+			       dpm_state_stats[i].count);+	}++	spin_unlock_irqrestore(&dpm_policy_lock, flags);+	return len;+}++static ssize_t state_stats_store(struct subsystem * subsys, const char * buf,+				 size_t n)+{+        return n;+}+#endif /* CONFIG_DPM_STATS */++static struct kobject dpm_state_kobj = {+	.kset = &dpm_subsys.kset,+};++dpm_attr(control, state_control);+dpm_attr(active, active_state);+#ifdef CONFIG_DPM_STATS+dpm_attr(stats, state_stats);+#endif++struct astate {+	int index;+	struct kobject kobj;+};++struct astate_attribute {+        struct attribute        attr;+        ssize_t (*show)(struct kobject * kobj, char * buf);+        ssize_t (*store)(struct kobject * kobj, const char * buf, size_t count);+};++#define to_astate(obj) container_of(obj,struct astate,kobj)+#define to_astate_attr(_attr) container_of(_attr,struct astate_attribute,attr)++static ssize_t+astate_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)+{+	struct astate_attribute * astate_attr = to_astate_attr(attr);+	ssize_t ret = 0;++	if (astate_attr->show)+		ret = astate_attr->show(kobj,buf);+	return ret;+}++static ssize_t+astate_attr_store(struct kobject * kobj, struct attribute * attr,+		  const char * buf, size_t count)+{+	struct astate_attribute * astate_attr = to_astate_attr(attr);+	ssize_t ret = 0;++	if (astate_attr->store)+		ret = astate_attr->store(kobj,buf,count);+	return ret;+}++static int show_opconstrains(int state, char *buf)+{+	struct dpm_opt *opt;+	int len = 0;++	if (dpm_active_policy->classopt[state].opt) {+		opt = dpm_active_policy->classopt[state].opt;++		len += dpm_show_opconstraints(opt, buf);+	}+	else {+		int i;++		for (i = 0;+		     i < dpm_active_policy->classopt[state].class->nops; i++) {+			len += dpm_show_opconstraints(+				dpm_active_policy->classopt[state].class->ops[i], buf);+		}+	}++	return len;+}+static ssize_t astate_constraints_show(struct kobject * kobj, char * buf)+{+	struct astate *astate = to_astate(kobj);+	ssize_t len = 0;++	if (dpm_enabled && dpm_active_policy)+		len = show_opconstrains(astate->index, buf);++	return len;+}++static ssize_t astate_constraints_store(struct kobject * kobj,+					const char * buf, size_t n)+{+	return n;+}++static struct astate_attribute astate_constraints_attr = {+        .attr   = {+                .name = "constraints",+                .mode = 0644,+        },+        .show   = astate_constraints_show,+        .store  = astate_constraints_store,+};++static struct sysfs_ops astate_sysfs_ops = {+	.show	= astate_attr_show,+	.store	= astate_attr_store,+};++static struct attribute * astate_default_attrs[] = {+	&astate_constraints_attr.attr,+	NULL,+};++static struct kobj_type ktype_astate = {+	.release        = dpm_kobj_release,+	.sysfs_ops	= &astate_sysfs_ops,+	.default_attrs	= astate_default_attrs,+};++static struct astate astate[DPM_STATES];++/*+ * Init+ */++static int __init dpm_sysfs_init(void)+{+        int error, i;++	error = subsystem_register(&dpm_subsys);+        if (!error)+                error = sysfs_create_group(&dpm_subsys.kset.kobj,&dpm_attr_group);+	if (!error) {+		kobject_set_name(&dpm_policy_kobj, "policy");+		kobject_register(&dpm_policy_kobj);+		sysfs_create_file(&dpm_policy_kobj, &policy_control_attr.attr);+		sysfs_create_file(&dpm_policy_kobj, &active_policy_attr.attr);+#ifdef CONFIG_DPM_STATS+		sysfs_create_file(&dpm_policy_kobj, &policy_stats_attr.attr);+#endif+		kobject_set_name(&dpm_class_kobj, "class");+		kobject_register(&dpm_class_kobj);+		sysfs_create_file(&dpm_class_kobj, &class_control_attr.attr);+		kobject_set_name(&dpm_op_kobj, "op");+		kobject_register(&dpm_op_kobj);+		sysfs_create_file(&dpm_op_kobj, &op_control_attr.attr);+#ifdef CONFIG_DPM_STATS+		sysfs_create_file(&dpm_op_kobj, &op_stats_attr.attr);+#endif+		kobject_set_name(&dpm_state_kobj, "state");+		kobject_register(&dpm_state_kobj);+		sysfs_create_file(&dpm_state_kobj, &state_control_attr.attr);+		sysfs_create_file(&dpm_state_kobj, &active_state_attr.attr);+#ifdef CONFIG_DPM_STATS+		sysfs_create_file(&dpm_state_kobj, &state_stats_attr.attr);+#endif++		for (i = 0; i < DPM_STATES; i++) {+			astate[i].index = i;+			astate[i].kobj.kset = &dpm_subsys.kset;+			kobject_set_name(&astate[i].kobj,dpm_state_names[i]);+			astate[i].kobj.parent = &dpm_state_kobj;+			astate[i].kobj.ktype = &ktype_astate;+			kobject_register(&astate[i].kobj);+		}+	}++        return error;+}++__initcall(dpm_sysfs_init);++/* /proc interface */++int dpm_set_task_state_by_name(struct task_struct *task, char *buf, ssize_t n)+{+	int task_state;+	int ret = 0;+	char *tbuf = NULL;+	char *token[MAXTOKENS];+	int ntoks = tokenizer(&tbuf, buf, n, (char **) &token, MAXTOKENS);++	if (ntoks <= 0) {+		ret = ntoks;+		goto out;+	}++	for (task_state = DPM_TASK_STATE - DPM_TASK_STATE_LIMIT;+	     task_state <= DPM_TASK_STATE + DPM_TASK_STATE_LIMIT;+	     task_state++)+		if (strcmp(token[0], dpm_state_names[task_state]) == 0) {+			task->dpm_state = task_state;++			if (task == current)+				dpm_set_os(task_state);++			ret = 0;+			break;+		}++out:+	if (tbuf)+		kfree(tbuf);++	return ret;+}Index: linux-2.6.16/drivers/dpm/dpm.c===================================================================--- linux-2.6.16.orig/drivers/dpm/dpm.c	1970-01-01 00:00:00.000000000 +0000+++ linux-2.6.16/drivers/dpm/dpm.c	2006-04-11 06:35:40.000000000 +0000@@ -0,0 +1,1117 @@+/*+ * drivers/dpm/policy.c  Dynamic Power Management Policies+ *+ * 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+ *+ * Copyright (C) 2002, International Business Machines Corporation+ * All Rights Reserved+ *+ * Robert Paulsen+ * IBM Linux Technology Center+ * rpaulsen@us.ibm.com+ * August, 2002+ *+ */++/* TODO:++   Rethink init/enable/disable: It may be redundant and/or unsafe+   Fix initialization and stats+*/++#include <linux/dpm.h>+#include <linux/init.h>+#include <linux/interrupt.h>+#include <linux/module.h>+#include <linux/proc_fs.h>+#include <linux/sched.h>+#include <linux/slab.h>+#include <linux/spinlock.h>+#include <linux/delay.h>+#include <linux/preempt.h>++#include <asm/semaphore.h>+#include <asm/system.h>+#include <asm/uaccess.h>++#undef TRACE+#if defined(TRACE)+#define trace(args...) do { printk("TRACE: "); printk(args); } while(0)+#else+#define trace(args...) do {} while(0)+#endif++struct dpm_md dpm_md;++static struct dpm_opt nop_op = {+	.name  = "[nop]",+	.flags = DPM_OP_NOP,+};++extern void dpm_force_off_constrainers(struct dpm_opt *opt);++unsigned long dpm_compute_lpj(unsigned long ref, u_int div, u_int mult)+{+	unsigned long new_jiffy_l, new_jiffy_h;++	/*+	 * Recalculate loops_per_jiffy.  We do it this way to+	 * avoid math overflow on 32-bit machines.  Maybe we+	 * should make this architecture dependent?  If you have+	 * a better way of doing this, please replace!+	 *+	 *    new = old * mult / div+	 */+	new_jiffy_h = ref / div;+	new_jiffy_l = (ref % div) / 100;+	new_jiffy_h *= mult;+	new_jiffy_l = new_jiffy_l * mult / div;+