![Greg Kroah-Hartman](/assets/img/avatar_default.png)
When calling debugfs functions, there is no need to ever check the return value. The function can work or not, but the code logic should never do something different based on this. Cc: Ralf Baechle <ralf@linux-mips.org> Cc: Paul Burton <paul.burton@mips.com> Cc: James Hogan <jhogan@kernel.org> Cc: linux-mips@vger.kernel.org Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> [paul.burton@mips.com: Remove return 0 from init_debugfs() as pointed out by Aaro Koskinen.] Signed-off-by: Paul Burton <paul.burton@mips.com>
182 lines
4.2 KiB
C
182 lines
4.2 KiB
C
#include <linux/fs.h>
|
|
#include <linux/interrupt.h>
|
|
#include <asm/octeon/octeon.h>
|
|
#include <asm/octeon/cvmx-ciu-defs.h>
|
|
#include <asm/octeon/cvmx.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/seq_file.h>
|
|
|
|
#define TIMER_NUM 3
|
|
|
|
static bool reset_stats;
|
|
|
|
struct latency_info {
|
|
u64 io_interval;
|
|
u64 cpu_interval;
|
|
u64 timer_start1;
|
|
u64 timer_start2;
|
|
u64 max_latency;
|
|
u64 min_latency;
|
|
u64 latency_sum;
|
|
u64 average_latency;
|
|
u64 interrupt_cnt;
|
|
};
|
|
|
|
static struct latency_info li;
|
|
static struct dentry *dir;
|
|
|
|
static int show_latency(struct seq_file *m, void *v)
|
|
{
|
|
u64 cpuclk, avg, max, min;
|
|
struct latency_info curr_li = li;
|
|
|
|
cpuclk = octeon_get_clock_rate();
|
|
|
|
max = (curr_li.max_latency * 1000000000) / cpuclk;
|
|
min = (curr_li.min_latency * 1000000000) / cpuclk;
|
|
avg = (curr_li.latency_sum * 1000000000) / (cpuclk * curr_li.interrupt_cnt);
|
|
|
|
seq_printf(m, "cnt: %10lld, avg: %7lld ns, max: %7lld ns, min: %7lld ns\n",
|
|
curr_li.interrupt_cnt, avg, max, min);
|
|
return 0;
|
|
}
|
|
|
|
static int oct_ilm_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, show_latency, NULL);
|
|
}
|
|
|
|
static const struct file_operations oct_ilm_ops = {
|
|
.open = oct_ilm_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int reset_statistics(void *data, u64 value)
|
|
{
|
|
reset_stats = true;
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(reset_statistics_ops, NULL, reset_statistics, "%llu\n");
|
|
|
|
static void init_debugfs(void)
|
|
{
|
|
dir = debugfs_create_dir("oct_ilm", 0);
|
|
debugfs_create_file("statistics", 0222, dir, NULL, &oct_ilm_ops);
|
|
debugfs_create_file("reset", 0222, dir, NULL, &reset_statistics_ops);
|
|
}
|
|
|
|
static void init_latency_info(struct latency_info *li, int startup)
|
|
{
|
|
/* interval in milli seconds after which the interrupt will
|
|
* be triggered
|
|
*/
|
|
int interval = 1;
|
|
|
|
if (startup) {
|
|
/* Calculating by the amounts io clock and cpu clock would
|
|
* increment in interval amount of ms
|
|
*/
|
|
li->io_interval = (octeon_get_io_clock_rate() * interval) / 1000;
|
|
li->cpu_interval = (octeon_get_clock_rate() * interval) / 1000;
|
|
}
|
|
li->timer_start1 = 0;
|
|
li->timer_start2 = 0;
|
|
li->max_latency = 0;
|
|
li->min_latency = (u64)-1;
|
|
li->latency_sum = 0;
|
|
li->interrupt_cnt = 0;
|
|
}
|
|
|
|
|
|
static void start_timer(int timer, u64 interval)
|
|
{
|
|
union cvmx_ciu_timx timx;
|
|
unsigned long flags;
|
|
|
|
timx.u64 = 0;
|
|
timx.s.one_shot = 1;
|
|
timx.s.len = interval;
|
|
raw_local_irq_save(flags);
|
|
li.timer_start1 = read_c0_cvmcount();
|
|
cvmx_write_csr(CVMX_CIU_TIMX(timer), timx.u64);
|
|
/* Read it back to force wait until register is written. */
|
|
timx.u64 = cvmx_read_csr(CVMX_CIU_TIMX(timer));
|
|
li.timer_start2 = read_c0_cvmcount();
|
|
raw_local_irq_restore(flags);
|
|
}
|
|
|
|
|
|
static irqreturn_t cvm_oct_ciu_timer_interrupt(int cpl, void *dev_id)
|
|
{
|
|
u64 last_latency;
|
|
u64 last_int_cnt;
|
|
|
|
if (reset_stats) {
|
|
init_latency_info(&li, 0);
|
|
reset_stats = false;
|
|
} else {
|
|
last_int_cnt = read_c0_cvmcount();
|
|
last_latency = last_int_cnt - (li.timer_start1 + li.cpu_interval);
|
|
li.interrupt_cnt++;
|
|
li.latency_sum += last_latency;
|
|
if (last_latency > li.max_latency)
|
|
li.max_latency = last_latency;
|
|
if (last_latency < li.min_latency)
|
|
li.min_latency = last_latency;
|
|
}
|
|
start_timer(TIMER_NUM, li.io_interval);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void disable_timer(int timer)
|
|
{
|
|
union cvmx_ciu_timx timx;
|
|
|
|
timx.s.one_shot = 0;
|
|
timx.s.len = 0;
|
|
cvmx_write_csr(CVMX_CIU_TIMX(timer), timx.u64);
|
|
/* Read it back to force immediate write of timer register*/
|
|
timx.u64 = cvmx_read_csr(CVMX_CIU_TIMX(timer));
|
|
}
|
|
|
|
static __init int oct_ilm_module_init(void)
|
|
{
|
|
int rc;
|
|
int irq = OCTEON_IRQ_TIMER0 + TIMER_NUM;
|
|
|
|
init_debugfs();
|
|
|
|
rc = request_irq(irq, cvm_oct_ciu_timer_interrupt, IRQF_NO_THREAD,
|
|
"oct_ilm", 0);
|
|
if (rc) {
|
|
WARN(1, "Could not acquire IRQ %d", irq);
|
|
goto err_irq;
|
|
}
|
|
|
|
init_latency_info(&li, 1);
|
|
start_timer(TIMER_NUM, li.io_interval);
|
|
|
|
return 0;
|
|
err_irq:
|
|
debugfs_remove_recursive(dir);
|
|
return rc;
|
|
}
|
|
|
|
static __exit void oct_ilm_module_exit(void)
|
|
{
|
|
disable_timer(TIMER_NUM);
|
|
debugfs_remove_recursive(dir);
|
|
free_irq(OCTEON_IRQ_TIMER0 + TIMER_NUM, 0);
|
|
}
|
|
|
|
module_exit(oct_ilm_module_exit);
|
|
module_init(oct_ilm_module_init);
|
|
MODULE_AUTHOR("Venkat Subbiah, Cavium");
|
|
MODULE_DESCRIPTION("Measures interrupt latency on Octeon chips.");
|
|
MODULE_LICENSE("GPL");
|