/*
 * Copyright (C) 2001-2013 Philippe Gerum <rpm@xenomai.org>.
 *
 * Xenomai 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.
 *
 * Xenomai 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 Xenomai; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#include <cobalt/kernel/lock.h>
#include <cobalt/kernel/clock.h>
#include <cobalt/kernel/vfile.h>
#include <cobalt/kernel/intr.h>
#include <cobalt/kernel/heap.h>
#include <cobalt/kernel/timer.h>
#include <cobalt/kernel/sched.h>
#include <xenomai/version.h>
#include "debug.h"

#ifdef CONFIG_XENO_OPT_DEBUG_LOCKING

static int lock_vfile_show(struct xnvfile_regular_iterator *it, void *data)
{
	struct xnlockinfo lockinfo;
	spl_t s;
	int cpu;

	for_each_realtime_cpu(cpu) {
		xnlock_get_irqsave(&nklock, s);
		lockinfo = per_cpu(xnlock_stats, cpu);
		xnlock_put_irqrestore(&nklock, s);

		if (cpu > 0)
			xnvfile_printf(it, "\n");

		xnvfile_printf(it, "CPU%d:\n", cpu);

		xnvfile_printf(it,
			     "  longest locked section: %llu ns\n"
			     "  spinning time: %llu ns\n"
			     "  section entry: %s:%d (%s)\n",
			       xnclock_ticks_to_ns(&nkclock, lockinfo.lock_time),
			       xnclock_ticks_to_ns(&nkclock, lockinfo.spin_time),
			       lockinfo.file, lockinfo.line, lockinfo.function);
	}

	return 0;
}

static ssize_t lock_vfile_store(struct xnvfile_input *input)
{
	ssize_t ret;
	spl_t s;
	int cpu;

	long val;

	ret = xnvfile_get_integer(input, &val);
	if (ret < 0)
		return ret;

	if (val != 0)
		return -EINVAL;

	for_each_realtime_cpu(cpu) {
		xnlock_get_irqsave(&nklock, s);
		memset(&per_cpu(xnlock_stats, cpu), '\0', sizeof(struct xnlockinfo));
		xnlock_put_irqrestore(&nklock, s);
	}

	return ret;
}

static struct xnvfile_regular_ops lock_vfile_ops = {
	.show = lock_vfile_show,
	.store = lock_vfile_store,
};

static struct xnvfile_regular lock_vfile = {
	.ops = &lock_vfile_ops,
};

#endif /* CONFIG_XENO_OPT_DEBUG_LOCKING */

static int latency_vfile_show(struct xnvfile_regular_iterator *it, void *data)
{
	xnvfile_printf(it, "%Lu\n",
		       xnclock_ticks_to_ns(&nkclock, nkclock.gravity.user));

	return 0;
}

static ssize_t latency_vfile_store(struct xnvfile_input *input)
{
	ssize_t ret;
	long val;

	ret = xnvfile_get_integer(input, &val);
	if (ret < 0)
		return ret;

	nkclock.gravity.user = xnclock_ns_to_ticks(&nkclock, val);

	return ret;
}

static struct xnvfile_regular_ops latency_vfile_ops = {
	.show = latency_vfile_show,
	.store = latency_vfile_store,
};

static struct xnvfile_regular latency_vfile = {
	.ops = &latency_vfile_ops,
};

static int version_vfile_show(struct xnvfile_regular_iterator *it, void *data)
{
	xnvfile_printf(it, "%s\n", XENO_VERSION_STRING);

	return 0;
}

static struct xnvfile_regular_ops version_vfile_ops = {
	.show = version_vfile_show,
};

static struct xnvfile_regular version_vfile = {
	.ops = &version_vfile_ops,
};

static int faults_vfile_show(struct xnvfile_regular_iterator *it, void *data)
{
	int cpu, trap;

	xnvfile_puts(it, "TRAP ");

	for_each_realtime_cpu(cpu)
		xnvfile_printf(it, "        CPU%d", cpu);

	for (trap = 0; cobalt_machine.fault_labels[trap]; trap++) {
		if (*cobalt_machine.fault_labels[trap] == '\0')
			continue;

		xnvfile_printf(it, "\n%3d: ", trap);

		for_each_realtime_cpu(cpu)
			xnvfile_printf(it, "%12u",
				       per_cpu(cobalt_machine_cpudata, cpu).faults[trap]);

		xnvfile_printf(it, "    (%s)",
			       cobalt_machine.fault_labels[trap]);
	}

	xnvfile_putc(it, '\n');

	return 0;
}

static struct xnvfile_regular_ops faults_vfile_ops = {
	.show = faults_vfile_show,
};

static struct xnvfile_regular faults_vfile = {
	.ops = &faults_vfile_ops,
};

void xnprocfs_cleanup_tree(void)
{
#ifdef CONFIG_XENO_OPT_DEBUG
#ifdef CONFIG_XENO_OPT_DEBUG_LOCKING
	xnvfile_destroy_regular(&lock_vfile);
#endif
	xnvfile_destroy_dir(&cobalt_debug_vfroot);
#endif /* XENO_OPT_DEBUG */
	xnvfile_destroy_regular(&faults_vfile);
	xnvfile_destroy_regular(&version_vfile);
	xnvfile_destroy_regular(&latency_vfile);
	xnintr_cleanup_proc();
	xnheap_cleanup_proc();
	xnclock_cleanup_proc();
	xnsched_cleanup_proc();
	xnvfile_destroy_root();
}

int __init xnprocfs_init_tree(void)
{
	int ret;

	ret = xnvfile_init_root();
	if (ret)
		return ret;

	ret = xnsched_init_proc();
	if (ret)
		return ret;

	xnclock_init_proc();
	xnheap_init_proc();
	xnintr_init_proc();
	xnvfile_init_regular("latency", &latency_vfile, &cobalt_vfroot);
	xnvfile_init_regular("version", &version_vfile, &cobalt_vfroot);
	xnvfile_init_regular("faults", &faults_vfile, &cobalt_vfroot);
#ifdef CONFIG_XENO_OPT_DEBUG
	xnvfile_init_dir("debug", &cobalt_debug_vfroot, &cobalt_vfroot);
#ifdef CONFIG_XENO_OPT_DEBUG_LOCKING
	xnvfile_init_regular("lock", &lock_vfile, &cobalt_debug_vfroot);
#endif
#endif

	return 0;
}