M7350/kernel/arch/arm/mach-msm/test-lpm.c
2024-09-09 08:52:07 +00:00

700 lines
18 KiB
C

/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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.
*
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pm.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/ctype.h>
#include <linux/moduleparam.h>
#include <linux/platform_device.h>
#include <mach/socinfo.h>
#if defined(CONFIG_MSM_RPM)
#include "rpm_resources.h"
#endif
#if defined(CONFIG_MSM_RPM_SMD)
#include "lpm_resources.h"
#endif
#include "timer.h"
#include "test-lpm.h"
#define LPM_STATS_RESET "reset"
#define LPM_TEST_ALL_LEVELS "lpm"
#define LPM_TEST_LATENCIES "latency"
#define LPM_TEST_CLEAR "clear"
#define BUF_SIZE 200
#define STAT_BUF_EXTRA_SIZE 500
#define WAIT_FOR_XO 1
#define COMM_BUF_SIZE 15
#define INPUT_COUNT_BUF 10
#define LPM_DEFAULT_CPU 0
#define SNPRINTF(buf, size, format, ...) \
{ \
if (size > 0) { \
int ret; \
ret = snprintf(buf, size, format, ## __VA_ARGS__); \
if (ret > size) { \
buf += size; \
size = 0; \
} else { \
buf += ret; \
size -= ret; \
} \
} \
} \
static DEFINE_MUTEX(lpm_stats_mutex);
struct lpm_level_stat {
char level_name[BUF_SIZE];
int64_t min_time;
int64_t max_time;
int64_t avg_time;
int64_t exit_early;
int64_t count;
unsigned long min_threshold;
uint32_t kernel_sleep_time;
bool entered;
};
static DEFINE_PER_CPU(struct lpm_level_stat *, lpm_levels);
static struct dentry *lpm_stat;
static struct dentry *lpm_ext_comm;
static struct msm_rpmrs_level *lpm_supp_level;
static int lpm_level_count;
static int lpm_level_iter;
static bool msm_lpm_use_qtimer;
static unsigned long lpm_sleep_time;
static bool lpm_latency_test;
static unsigned int timer_interval = 5000;
module_param_named(lpm_timer_interval_msec, timer_interval, uint,
S_IRUGO | S_IWUSR | S_IWGRP);
static unsigned int latency_test_interval = 50;
module_param_named(lpm_latency_timer_interval_usec, latency_test_interval, uint,
S_IRUGO | S_IWUSR | S_IWGRP);
static unsigned int cpu_to_debug = LPM_DEFAULT_CPU;
static int lpm_cpu_update(const char *val, const struct kernel_param *kp)
{
int ret = 0;
unsigned int debug_val;
ret = kstrtouint(val, 10, &debug_val);
if ((ret < 0) || (debug_val >= num_possible_cpus()))
return -EINVAL;
cpu_to_debug = debug_val;
return ret;
}
static struct kernel_param_ops cpu_debug_events = {
.set = lpm_cpu_update,
};
module_param_cb(cpu_to_debug, &cpu_debug_events, &cpu_to_debug,
S_IRUGO | S_IWUSR | S_IWGRP);
static void lpm_populate_name(struct lpm_level_stat *stat,
struct msm_rpmrs_level *supp)
{
char nm[BUF_SIZE] = {0};
char default_buf[20];
switch (supp->sleep_mode) {
case MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT:
strlcat(nm, "WFI ", BUF_SIZE);
break;
case MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT:
strlcat(nm, "WFI voltage Rampdown ", BUF_SIZE);
break;
case MSM_PM_SLEEP_MODE_RETENTION:
strlcat(nm, "Retention ", BUF_SIZE);
break;
case MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE:
strlcat(nm, "Standalone Power collapse ", BUF_SIZE);
break;
case MSM_PM_SLEEP_MODE_POWER_COLLAPSE:
strlcat(nm, "Idle Power collapse ", BUF_SIZE);
break;
case MSM_PM_SLEEP_MODE_POWER_COLLAPSE_SUSPEND:
strlcat(nm, "Suspend Power collapse ", BUF_SIZE);
break;
default:
strlcat(nm, "Invalid Mode ", BUF_SIZE);
break;
}
switch (msm_pm_get_pxo(&(supp->rs_limits))) {
case MSM_PM(PXO_OFF):
strlcat(nm, "XO: OFF ", BUF_SIZE);
break;
case MSM_PM(PXO_ON):
strlcat(nm, "XO: ON ", BUF_SIZE);
break;
default:
snprintf(default_buf, sizeof(default_buf),
"XO : %d ", msm_pm_get_pxo(&(supp->rs_limits)));
strlcat(nm, default_buf , BUF_SIZE);
break;
}
switch (msm_pm_get_l2_cache(&(supp->rs_limits))) {
case MSM_PM(L2_CACHE_HSFS_OPEN):
strlcat(nm, "L2: HSFS ", BUF_SIZE);
break;
case MSM_PM(L2_CACHE_GDHS):
strlcat(nm, "L2: GDHS ", BUF_SIZE);
break;
case MSM_PM(L2_CACHE_RETENTION):
strlcat(nm, "L2: Retention ", BUF_SIZE);
break;
case MSM_PM(L2_CACHE_ACTIVE):
strlcat(nm, "L2: Active ", BUF_SIZE);
break;
default:
snprintf(default_buf, sizeof(default_buf),
"L2 : %d ", msm_pm_get_l2_cache(&(supp->rs_limits)));
strlcat(nm, default_buf , BUF_SIZE);
break;
}
snprintf(default_buf, sizeof(default_buf),
"Vdd_mem : %d ", msm_pm_get_vdd_mem(&(supp->rs_limits)));
strlcat(nm, default_buf , BUF_SIZE);
snprintf(default_buf, sizeof(default_buf),
"Vdd_dig : %d ", msm_pm_get_vdd_dig(&(supp->rs_limits)));
strlcat(nm, default_buf , BUF_SIZE);
strlcpy(stat->level_name, nm, strnlen(nm, BUF_SIZE));
}
static int64_t msm_lpm_get_time(void)
{
if (msm_lpm_use_qtimer)
return ktime_to_ns(ktime_get());
return msm_timer_get_sclk_time(NULL);
}
static bool lpm_get_level(void *v, unsigned int *ct)
{
bool ret = false;
int it;
struct msm_rpmrs_level *level_enter;
level_enter = container_of(((struct msm_lpm_sleep_data *)v)->limits,
struct msm_rpmrs_level, rs_limits);
if (level_enter) {
for (it = 0; it < lpm_level_count; it++)
if (!memcmp(level_enter , lpm_supp_level + it,
sizeof(struct msm_rpmrs_level))) {
*ct = it;
ret = true;
break;
}
}
return ret;
}
static int lpm_callback(struct notifier_block *self, unsigned long cmd,
void *sleep_data)
{
static int64_t time;
unsigned int ct;
struct lpm_level_stat *stats;
stats = per_cpu(lpm_levels, cpu_to_debug);
/* Update the stats and get the start/stop time */
if (cmd == MSM_LPM_STATE_ENTER && !lpm_latency_test) {
time = msm_lpm_get_time();
stats[lpm_level_iter].entered = true;
} else if ((cmd == MSM_LPM_STATE_EXIT) && (time)
&& (!lpm_latency_test)) {
int64_t time1;
time1 = msm_lpm_get_time();
time = time1 - time;
if ((time < stats[lpm_level_iter].min_time) ||
(!stats[lpm_level_iter].min_time))
stats[lpm_level_iter].min_time = time;
if (time > stats[lpm_level_iter].max_time)
stats[lpm_level_iter].max_time = time;
time1 = stats[lpm_level_iter].avg_time *
stats[lpm_level_iter].count + time;
do_div(time1, ++(stats[lpm_level_iter].count));
stats[lpm_level_iter].avg_time = time1;
do_div(time, NSEC_PER_USEC);
if (time < lpm_supp_level[lpm_level_iter].
time_overhead_us)
stats[lpm_level_iter].exit_early++;
time = 0;
} else if (cmd == MSM_LPM_STATE_ENTER && lpm_latency_test) {
struct msm_lpm_sleep_data *data = sleep_data;
if ((lpm_get_level(sleep_data, &ct)) &&
(stats[ct].min_threshold == 0) &&
data->kernel_sleep <= lpm_sleep_time) {
stats[ct].min_threshold = lpm_sleep_time;
stats[ct].kernel_sleep_time =
data->kernel_sleep;
}
}
return 0;
}
static struct notifier_block lpm_idle_nb = {
.notifier_call = lpm_callback,
};
static void lpm_test_initiate(int lpm_level_test)
{
int test_ret;
/* This will communicate to 'stat' debugfs to skip latency printing*/
lpm_sleep_time = 0;
lpm_latency_test = false;
/* Unregister any infinitely registered level*/
msm_lpm_unregister_notifier(cpu_to_debug, &lpm_idle_nb);
/* Register/Unregister for Notification */
while (lpm_level_iter < lpm_level_count) {
test_ret = msm_lpm_register_notifier(cpu_to_debug,
lpm_level_iter, &lpm_idle_nb, false);
if (test_ret < 0) {
pr_err("%s: Registering notifier failed\n", __func__);
return;
}
if (!timer_interval)
break;
msleep(timer_interval);
msm_lpm_unregister_notifier(cpu_to_debug, &lpm_idle_nb);
if (lpm_level_test == lpm_level_count)
lpm_level_iter++;
else
break;
}
}
static void lpm_latency_test_initiate(unsigned long max_time)
{
int test_ret;
lpm_latency_test = true;
lpm_sleep_time = latency_test_interval;
msm_lpm_unregister_notifier(cpu_to_debug, &lpm_idle_nb);
if (max_time > lpm_sleep_time) {
do {
test_ret = msm_lpm_register_notifier(cpu_to_debug,
lpm_level_count + 1,
&lpm_idle_nb, true);
if (test_ret) {
pr_err("%s: Registering notifier failed\n",
__func__);
return;
}
usleep(lpm_sleep_time);
/*Unregister to ensure that we dont update the latency
during the timer value transistion*/
msm_lpm_unregister_notifier(cpu_to_debug,
&lpm_idle_nb);
lpm_sleep_time += latency_test_interval;
} while (lpm_sleep_time < max_time);
} else
pr_err("%s: Invalid time interval specified\n", __func__);
lpm_latency_test = false;
}
static ssize_t lpm_test_comm_read(struct file *fp, char __user *user_buffer,
size_t buffer_length, loff_t *position)
{
int i = 0;
int count = buffer_length;
int alloc_size = 100 * lpm_level_count;
char *temp_buf;
char *comm_buf;
ssize_t ret;
comm_buf = kzalloc(alloc_size, GFP_KERNEL);
if (!comm_buf) {
pr_err("%s:Memory alloc failed\n", __func__);
ret = 0;
goto com_read_failed;
}
temp_buf = comm_buf;
SNPRINTF(temp_buf, count, "Low power modes available:\n");
for (i = 0; i < lpm_level_count; i++)
SNPRINTF(temp_buf, count, "%d. %s\n", i,
per_cpu(lpm_levels, cpu_to_debug)[i].level_name);
SNPRINTF(temp_buf, count, "%d. MSM test all lpm\n", i++);
SNPRINTF(temp_buf, count, "%d. MSM determine latency\n", i);
ret = simple_read_from_buffer(user_buffer, buffer_length - count,
position, comm_buf, alloc_size);
kfree(comm_buf);
com_read_failed:
return ret;
}
char *trimspaces(char *time_buf)
{
int len;
char *tail;
len = strnlen(time_buf, INPUT_COUNT_BUF);
tail = time_buf + len;
while (isspace(*time_buf) && (time_buf != tail))
time_buf++;
if (time_buf == tail) {
time_buf = NULL;
goto exit_trim_spaces;
}
len = strnlen(time_buf, INPUT_COUNT_BUF);
tail = time_buf + len - 1;
while (isspace(*tail) && tail != time_buf) {
*tail = '\0';
tail--;
}
exit_trim_spaces:
return time_buf;
}
static ssize_t lpm_test_comm_write(struct file *fp, const char __user
*user_buffer, size_t count, loff_t *position)
{
ssize_t ret;
int str_ret;
int lpm_level_test;
char *new_ptr;
char *comm_buf;
comm_buf = kzalloc(COMM_BUF_SIZE, GFP_KERNEL);
if (!comm_buf) {
pr_err("\'%s\': kzalloc failed\n", __func__);
return -EINVAL;
}
memset(comm_buf, '\0', COMM_BUF_SIZE);
ret = simple_write_to_buffer(comm_buf, COMM_BUF_SIZE, position,
user_buffer, count);
new_ptr = trimspaces(comm_buf);
if (!new_ptr) {
pr_err("%s: Test case number input invalid\n", __func__);
goto write_com_failed;
}
if (!memcmp(comm_buf, LPM_TEST_ALL_LEVELS,
sizeof(LPM_TEST_ALL_LEVELS) - 1)) {
lpm_level_test = lpm_level_count;
lpm_level_iter = 0;
lpm_test_initiate(lpm_level_test);
goto write_com_success;
} else if (!memcmp(comm_buf, LPM_TEST_LATENCIES,
sizeof(LPM_TEST_LATENCIES) - 1)) {
lpm_level_test = lpm_level_count + 1;
lpm_latency_test_initiate(timer_interval * USEC_PER_MSEC);
goto write_com_success;
} else if (!memcmp(comm_buf, LPM_TEST_CLEAR,
sizeof(LPM_TEST_CLEAR) - 1)) {
msm_lpm_unregister_notifier(cpu_to_debug, &lpm_idle_nb);
goto write_com_success;
}
str_ret = kstrtoint(new_ptr, 10, &lpm_level_test);
if ((str_ret) || (lpm_level_test > (lpm_level_count + 1)) ||
(lpm_level_test < 0))
goto write_com_failed;
lpm_level_iter = lpm_level_test;
lpm_test_initiate(lpm_level_test);
goto write_com_success;
write_com_failed:
ret = -EINVAL;
write_com_success:
kfree(comm_buf);
return ret;
}
static ssize_t lpm_test_stat_read(struct file *fp, char __user *user_buffer,
size_t buffer_length, loff_t *position)
{
int i = 0;
int j = 0;
int count = buffer_length;
char *stat_buf;
char *stat_buf_start;
size_t stat_buf_size;
ssize_t ret;
int64_t min_ns;
int64_t max_ns;
int64_t avg_ns;
uint32_t min_ms;
uint32_t max_ms;
uint32_t avg_ms;
stat_buf_size = ((sizeof(struct lpm_level_stat) * lpm_level_count) +
STAT_BUF_EXTRA_SIZE);
stat_buf = kzalloc(stat_buf_size, GFP_KERNEL);
if (!stat_buf) {
pr_err("\'%s\': kzalloc failed\n", __func__);
return -EINVAL;
}
stat_buf_start = stat_buf;
mutex_lock(&lpm_stats_mutex);
memset(stat_buf, '\0', stat_buf_size);
SNPRINTF(stat_buf, count, "\n\nStats for CPU: %d\nTotal Levels: %d\n",
cpu_to_debug, lpm_level_count);
if (!lpm_sleep_time) {
SNPRINTF(stat_buf, count, "Level(s) failed: ");
for (i = 0 ; i < lpm_level_count; i++) {
if (per_cpu(lpm_levels, cpu_to_debug)[i].entered)
continue;
else {
SNPRINTF(stat_buf, count,
"\n%d. %s", ++j, per_cpu(lpm_levels,
cpu_to_debug)[i].level_name);
}
}
SNPRINTF(stat_buf, count, "\n\nSTATS:");
for (i = 0; i < lpm_level_count; i++) {
min_ns = per_cpu(lpm_levels, cpu_to_debug)[i].min_time;
min_ms = do_div(min_ns, NSEC_PER_MSEC);
max_ns = per_cpu(lpm_levels, cpu_to_debug)[i].max_time;
max_ms = do_div(max_ns, NSEC_PER_MSEC);
avg_ns = per_cpu(lpm_levels, cpu_to_debug)[i].avg_time;
avg_ms = do_div(avg_ns, NSEC_PER_MSEC);
SNPRINTF(stat_buf, count, "\nLEVEL: %s\n"
"Entered : %lld\n"
"Early wakeup : %lld\n"
"Min Time (mSec): %lld.%06u\n"
"Max Time (mSec): %lld.%06u\n"
"Avg Time (mSec): %lld.%06u\n",
per_cpu(lpm_levels, cpu_to_debug)[i].level_name,
per_cpu(lpm_levels, cpu_to_debug)[i].count,
per_cpu(lpm_levels, cpu_to_debug)[i].exit_early,
min_ns, min_ms,
max_ns, max_ms,
avg_ns, avg_ms);
}
} else {
for (i = 0; i < lpm_level_count; i++) {
SNPRINTF(stat_buf, count, "\nLEVEL: %s\n"
"Min Timer value (uSec): %lu\n"
"Kernel sleep time (uSec): %u\n",
per_cpu(lpm_levels, cpu_to_debug)[i].level_name,
per_cpu(lpm_levels, cpu_to_debug)[i].
min_threshold,
per_cpu(lpm_levels,
cpu_to_debug)[i].kernel_sleep_time);
}
}
ret = simple_read_from_buffer(user_buffer, buffer_length - count,
position, stat_buf_start, stat_buf_size);
mutex_unlock(&lpm_stats_mutex);
kfree(stat_buf_start);
return ret;
}
static ssize_t lpm_test_stat_write(struct file *fp, const char __user
*user_buffer, size_t count, loff_t *position)
{
char buf[sizeof(LPM_STATS_RESET)];
int ret;
int i;
struct lpm_level_stat *stats;
if (count > sizeof(LPM_STATS_RESET)) {
ret = -EINVAL;
goto write_debug_failed;
}
simple_write_to_buffer(buf, sizeof(LPM_STATS_RESET), position,
user_buffer, count);
if (memcmp(buf, LPM_STATS_RESET, sizeof(LPM_STATS_RESET) - 1)) {
ret = -EINVAL;
goto write_debug_failed;
}
mutex_lock(&lpm_stats_mutex);
stats = per_cpu(lpm_levels, cpu_to_debug);
for (i = 0 ; i < lpm_level_count; i++) {
stats[i].entered = 0;
stats[i].min_time = 0;
stats[i].max_time = 0;
stats[i].avg_time = 0;
stats[i].count = 0;
stats[i].exit_early = 0;
stats[i].min_threshold = 0;
stats[i].kernel_sleep_time = 0;
}
mutex_unlock(&lpm_stats_mutex);
return count;
write_debug_failed:
return ret;
}
static void lpm_init_rpm_levels(int test_lpm_level_count,
struct msm_rpmrs_level *test_levels)
{
int i = 0;
unsigned int m_cpu = 0;
struct lpm_level_stat *stat_levels = NULL;
if (test_lpm_level_count < 0)
return;
lpm_level_count = test_lpm_level_count;
lpm_supp_level = test_levels;
for_each_possible_cpu(m_cpu) {
stat_levels = kzalloc(sizeof(struct lpm_level_stat) *
lpm_level_count, GFP_KERNEL);
if (!stat_levels) {
for (i = m_cpu - 1; i >= 0; i--)
kfree(per_cpu(lpm_levels, i));
return;
}
for (i = 0; i < lpm_level_count; i++)
lpm_populate_name(&stat_levels[i], &lpm_supp_level[i]);
per_cpu(lpm_levels, m_cpu) = stat_levels;
}
}
static const struct file_operations fops_stat = {
.read = lpm_test_stat_read,
.write = lpm_test_stat_write,
};
static const struct file_operations fops_comm = {
.read = lpm_test_comm_read,
.write = lpm_test_comm_write,
};
static int __devinit lpm_test_init(int test_lpm_level_count,
struct msm_rpmrs_level *test_levels)
{
int filevalue;
int lpm_comm;
int ret = -EINVAL;
struct dentry *parent_dir = NULL;
parent_dir = debugfs_create_dir("msm_lpm_debug", NULL);
if (!parent_dir) {
pr_err("%s: debugfs directory creation failed\n",
__func__);
goto init_err;
}
lpm_stat = debugfs_create_file("stat",
S_IRUGO | S_IWUSR | S_IWGRP, parent_dir,
&filevalue, &fops_stat);
if (!lpm_stat) {
pr_err("%s: lpm_stats debugfs creation failed\n",
__func__);
goto init_err;
}
lpm_ext_comm = debugfs_create_file("comm",
S_IRUGO | S_IWUSR | S_IWGRP, parent_dir, &lpm_comm,
&fops_comm);
if (!lpm_ext_comm) {
pr_err("%s: lpm_comm debugfs creation failed\n",
__func__);
debugfs_remove(lpm_stat);
goto init_err;
}
/*Query RPM resources and allocate the data sturctures*/
lpm_init_rpm_levels(test_lpm_level_count, test_levels);
ret = 0;
init_err:
return ret;
}
static int __devexit lpm_test_exit(struct platform_device *pdev)
{
unsigned int m_cpu = 0;
kfree(lpm_supp_level);
for_each_possible_cpu(m_cpu)
kfree(per_cpu(lpm_levels, m_cpu));
debugfs_remove(lpm_stat);
debugfs_remove(lpm_ext_comm);
return 0;
}
static int __devinit lpm_test_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct lpm_test_platform_data *pdata;
struct msm_rpmrs_level *test_levels;
int test_lpm_level_count;
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(dev, "no platform data specified\n");
return -EINVAL;
}
test_levels = pdata->msm_lpm_test_levels;
test_lpm_level_count = pdata->msm_lpm_test_level_count;
if (pdata->use_qtimer)
msm_lpm_use_qtimer = true;
lpm_test_init(test_lpm_level_count, test_levels);
return 0;
}
static struct platform_driver lpm_test_driver = {
.probe = lpm_test_probe,
.remove = lpm_test_exit,
.driver = {
.name = "lpm_test",
.owner = THIS_MODULE,
},
};
static int __init lpm_test_platform_driver_init(void)
{
return platform_driver_register(&lpm_test_driver);
}
late_initcall(lpm_test_platform_driver_init);