static int
read_proc_dpm_opt_stats(char *page, char **start, off_t offset,
int count, int *eof, void *data)
{
int len = 0;
struct dpm_opt *opt;
struct list_head *p;
dpm_md_time_t total_time;
if (dpm_lock_interruptible())
return -ERESTARTSYS;
if (!dpm_enabled) {
dpm_unlock();
len += sprintf(page + len, "DPM IS DISABLED\n");
*eof = 1;
return len;
}
for (p = dpm_opts.next; p != &dpm_opts; p = p->next) {
opt = list_entry(p, struct dpm_opt, list);
len += sprintf(page + len, "%s", opt->name);
total_time = opt->stats.total_time;
if (opt == dpm_active_opt)
total_time += dpm_md_time() - opt->stats.start_time;
len += sprintf_u64(page + len, 0, " ", opt->stats.total_time);
len += sprintf_u64(page + len, 0, " ", opt->stats.count);
len += sprintf(page + len, "\n");
}
dpm_unlock();
*eof = 1;
return len;
}
static int
read_proc_dpm_state(char *page, char **start, off_t offset,
int count, int *eof, void *data)
{
unsigned long flags;
int len = 0;
if (dpm_lock_interruptible())
return -ERESTARTSYS;
if (!dpm_enabled) {
len += sprintf(page + len, "N/A -1 N/A N/A N/A N/A %d\n",
DPM_MD_HZ);
} else {
spin_lock_irqsave(&dpm_policy_lock, flags);
len += sprintf(page + len,"%s %d %s %s %s %s %d\n",
dpm_active_policy->name,
dpm_active_state,
dpm_state_names[dpm_active_state],
dpm_active_policy->
classes[dpm_active_state]->name,
dpm_active_policy->
classes[dpm_active_state]->opt->name,
dpm_active_opt->name,
DPM_MD_HZ);
spin_unlock_irqrestore(&dpm_policy_lock, flags);
}
dpm_unlock();
*eof = 1;
return len;
}
static int
u_dpm_get_all_policies(char *u_name, char **u_policy_names)
{
int i = 0, count;
char *policy_names[238];
dpm_lock();
count = dpm_get_all_policies(policy_names);
for(i = 0; i < count; i++) {
if (0 != copy_to_user(u_policy_names[i], policy_names[i],
strlen(policy_names[i]) + 1)) {
dpm_unlock();
return -EFAULT;
}
}
dpm_unlock();
return 0;
}
int
u_dpm_get_policy(char *u_name)
{
char *name;
dpm_lock();
if (!dpm_active_policy) {
dpm_unlock();
return -ENOENT;
}
name = dpm_active_policy->name;
if (0 != copy_to_user(u_name, name, strlen(name) + 1)) {
dpm_unlock();
return -EFAULT;
}
dpm_unlock();
return 0;
}
void
dpm_idle(void)
{
unsigned long flags;
struct dpm_idle_parms *idle_parms = &dpm_idle_parms;
struct dpm_opt *idle_task_opt, *idle_opt;
current->dpm_state = DPM_NO_STATE;
dpm_set_os(DPM_IDLE_TASK_STATE);
dpm_md_idle_set_parms(&idle_parms->md);
#ifdef EXTREME_WORST_CASE
flush_instruction_cache();
flush_dcache_all();
local_flush_tlb_all();
#endif
critical_save_and_cli(flags);
if (!current->need_resched) {
incr_stat(idles);
stat_start_time(idle_parms);
if (!dpm_enabled) {
basic_idle(idle_parms);
} else if (dpm_active_state != DPM_IDLE_TASK_STATE) {
incr_stat(interrupted_idles);
} else {
idle_task_opt = dpm_active_policy->
classes[DPM_IDLE_TASK_STATE]->opt;
idle_opt = dpm_active_policy->
classes[DPM_IDLE_STATE]->opt;
if ((dpm_active_opt != idle_task_opt) ||
(idle_task_opt == idle_opt) ||
dpm_trylock()) {
quick_idle(idle_parms);
} else {
dpm_unlock();
full_idle(idle_parms, idle_task_opt, idle_opt);
}
}
latency_stats(idle_parms);
}
critical_restore_flags(flags);
}
