/***
 *
 *  stack/rtnet_module.c - module framework, proc file system
 *
 *  Copyright (C) 2002      Ulrich Marx <marx@kammer.uni-hannover.de>
 *                2003-2006 Jan Kiszka <jan.kiszka@web.de>
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

#include <rtdev_mgr.h>
#include <rtnet_chrdev.h>
#include <rtnet_internal.h>
#include <rtnet_socket.h>
#include <rtnet_rtpc.h>
#include <stack_mgr.h>
#include <rtwlan.h>

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("RTnet stack core");

struct class *rtnet_class;

struct rtnet_mgr STACK_manager;
struct rtnet_mgr RTDEV_manager;

EXPORT_SYMBOL_GPL(STACK_manager);
EXPORT_SYMBOL_GPL(RTDEV_manager);

const char rtnet_rtdm_provider_name[] =
	"(C) 1999-2008 RTnet Development Team, http://www.rtnet.org";

EXPORT_SYMBOL_GPL(rtnet_rtdm_provider_name);

void rtnet_corectl_register(void);
void rtnet_corectl_unregister(void);

#ifdef CONFIG_XENO_OPT_VFILE
/***
 *      proc filesystem section
 */
struct xnvfile_directory rtnet_proc_root;
EXPORT_SYMBOL_GPL(rtnet_proc_root);

static int rtnet_devices_nrt_lock_get(struct xnvfile *vfile)
{
	return mutex_lock_interruptible(&rtnet_devices_nrt_lock);
}

static void rtnet_devices_nrt_lock_put(struct xnvfile *vfile)
{
	mutex_unlock(&rtnet_devices_nrt_lock);
}

static struct xnvfile_lock_ops rtnet_devices_nrt_lock_ops = {
	.get = rtnet_devices_nrt_lock_get,
	.put = rtnet_devices_nrt_lock_put,
};

static void *rtnet_devices_begin(struct xnvfile_regular_iterator *it)
{
	if (it->pos == 0)
		return VFILE_SEQ_START;

	return (void *)2UL;
}

static void *rtnet_devices_next(struct xnvfile_regular_iterator *it)
{
	if (it->pos >= MAX_RT_DEVICES)
		return NULL;

	return (void *)2UL;
}

static int rtnet_devices_show(struct xnvfile_regular_iterator *it, void *data)
{
	struct rtnet_device *rtdev;

	if (data == NULL) {
		xnvfile_printf(it, "Index\tName\t\tFlags\n");
		return 0;
	}

	rtdev = __rtdev_get_by_index(it->pos);
	if (rtdev == NULL)
		return VFILE_SEQ_SKIP;

	xnvfile_printf(it, "%d\t%-15s %s%s%s%s\n", rtdev->ifindex, rtdev->name,
		       (rtdev->flags & IFF_UP) ? "UP" : "DOWN",
		       (rtdev->flags & IFF_BROADCAST) ? " BROADCAST" : "",
		       (rtdev->flags & IFF_LOOPBACK) ? " LOOPBACK" : "",
		       (rtdev->flags & IFF_PROMISC) ? " PROMISC" : "");
	return 0;
}

static struct xnvfile_regular_ops rtnet_devices_vfile_ops = {
	.begin = rtnet_devices_begin,
	.next = rtnet_devices_next,
	.show = rtnet_devices_show,
};

static struct xnvfile_regular rtnet_devices_vfile = {
	.entry = { .lockops = &rtnet_devices_nrt_lock_ops, },
	.ops = &rtnet_devices_vfile_ops,
};

static int rtnet_rtskb_show(struct xnvfile_regular_iterator *it, void *data)
{
	unsigned int rtskb_len;

	rtskb_len = ALIGN_RTSKB_STRUCT_LEN + SKB_DATA_ALIGN(RTSKB_SIZE);

	xnvfile_printf(it,
		       "Statistics\t\tCurrent\tMaximum\n"
		       "rtskb pools\t\t%d\t%d\n"
		       "rtskbs\t\t\t%d\t%d\n"
		       "rtskb memory need\t%d\t%d\n",
		       rtskb_pools, rtskb_pools_max, rtskb_amount,
		       rtskb_amount_max, rtskb_amount * rtskb_len,
		       rtskb_amount_max * rtskb_len);
	return 0;
}

static struct xnvfile_regular_ops rtnet_rtskb_vfile_ops = {
	.show = rtnet_rtskb_show,
};

static struct xnvfile_regular rtnet_rtskb_vfile = {
	.ops = &rtnet_rtskb_vfile_ops,
};

static int rtnet_version_show(struct xnvfile_regular_iterator *it, void *data)
{
	const char verstr[] = "RTnet for Xenomai v" XENO_VERSION_STRING "\n"
			      "RTcap:      "
#if IS_ENABLED(CONFIG_XENO_DRIVERS_NET_ADDON_RTCAP)
			      "yes\n"
#else
			      "no\n"
#endif
			      "rtnetproxy: "
#if IS_ENABLED(CONFIG_XENO_DRIVERS_NET_ADDON_PROXY)
			      "yes\n"
#else
			      "no\n"
#endif
			      "bug checks: "
#ifdef CONFIG_XENO_DRIVERS_NET_CHECKED
			      "yes\n"
#else
			      "no\n"
#endif
		;

	xnvfile_printf(it, "%s", verstr);

	return 0;
}

static struct xnvfile_regular_ops rtnet_version_vfile_ops = {
	.show = rtnet_version_show,
};

static struct xnvfile_regular rtnet_version_vfile = {
	.ops = &rtnet_version_vfile_ops,
};

static void *rtnet_stats_begin(struct xnvfile_regular_iterator *it)
{
	return (void *)1UL;
}

static void *rtnet_stats_next(struct xnvfile_regular_iterator *it)
{
	if (it->pos >= MAX_RT_DEVICES)
		return NULL;

	return (void *)1UL;
}

static int rtnet_stats_show(struct xnvfile_regular_iterator *it, void *data)
{
	struct net_device_stats *stats;
	struct rtnet_device *rtdev;

	if (it->pos == 0) {
		xnvfile_printf(it,
			       "Inter-|   Receive                            "
			       "                    |  Transmit\n");
		xnvfile_printf(it,
			       " face |bytes    packets errs drop fifo frame "
			       "compressed multicast|bytes    packets errs "
			       "drop fifo colls carrier compressed\n");
		return 0;
	}

	rtdev = __rtdev_get_by_index(it->pos);
	if (rtdev == NULL)
		return VFILE_SEQ_SKIP;

	if (rtdev->get_stats == NULL) {
		xnvfile_printf(it, "%6s: No statistics available.\n",
			       rtdev->name);
		return 0;
	}

	stats = rtdev->get_stats(rtdev);
	xnvfile_printf(
		it,
		"%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
		"%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
		rtdev->name, stats->rx_bytes, stats->rx_packets,
		stats->rx_errors, stats->rx_dropped + stats->rx_missed_errors,
		stats->rx_fifo_errors,
		stats->rx_length_errors + stats->rx_over_errors +
			stats->rx_crc_errors + stats->rx_frame_errors,
		stats->rx_compressed, stats->multicast, stats->tx_bytes,
		stats->tx_packets, stats->tx_errors, stats->tx_dropped,
		stats->tx_fifo_errors, stats->collisions,
		stats->tx_carrier_errors + stats->tx_aborted_errors +
			stats->tx_window_errors + stats->tx_heartbeat_errors,
		stats->tx_compressed);
	return 0;
}

static struct xnvfile_regular_ops rtnet_stats_vfile_ops = {
	.begin = rtnet_stats_begin,
	.next = rtnet_stats_next,
	.show = rtnet_stats_show,
};

static struct xnvfile_regular rtnet_stats_vfile = {
	.entry = { .lockops = &rtnet_devices_nrt_lock_ops, },
	.ops = &rtnet_stats_vfile_ops,
};

static int rtnet_proc_register(void)
{
	int err;

	err = xnvfile_init_dir("rtnet", &rtnet_proc_root, NULL);
	if (err < 0)
		goto error1;

	err = xnvfile_init_regular("devices", &rtnet_devices_vfile,
				   &rtnet_proc_root);
	if (err < 0)
		goto error2;

	err = xnvfile_init_regular("rtskb", &rtnet_rtskb_vfile,
				   &rtnet_proc_root);
	if (err < 0)
		goto error3;

	err = xnvfile_init_regular("version", &rtnet_version_vfile,
				   &rtnet_proc_root);
	if (err < 0)
		goto error4;

	err = xnvfile_init_regular("stats", &rtnet_stats_vfile,
				   &rtnet_proc_root);
	if (err < 0)
		goto error5;

	return 0;

error5:
	xnvfile_destroy_regular(&rtnet_version_vfile);

error4:
	xnvfile_destroy_regular(&rtnet_rtskb_vfile);

error3:
	xnvfile_destroy_regular(&rtnet_devices_vfile);

error2:
	xnvfile_destroy_dir(&rtnet_proc_root);

error1:
	printk("RTnet: unable to initialize /proc entries\n");
	return err;
}

static void rtnet_proc_unregister(void)
{
	xnvfile_destroy_regular(&rtnet_stats_vfile);
	xnvfile_destroy_regular(&rtnet_version_vfile);
	xnvfile_destroy_regular(&rtnet_rtskb_vfile);
	xnvfile_destroy_regular(&rtnet_devices_vfile);
	xnvfile_destroy_dir(&rtnet_proc_root);
}
#endif /* CONFIG_XENO_OPT_VFILE */

/**
 *  rtnet_init()
 */
int __init rtnet_init(void)
{
	int err = 0;

	if (!rtdm_available())
		return -ENOSYS;

	printk("\n*** RTnet for Xenomai v" XENO_VERSION_STRING " ***\n\n");
	printk("RTnet: initialising real-time networking\n");

	rtnet_class = class_create(THIS_MODULE, "rtnet");
	if (IS_ERR(rtnet_class))
		return PTR_ERR(rtnet_class);

	if ((err = rtskb_pools_init()) != 0)
		goto err_out1;

#ifdef CONFIG_XENO_OPT_VFILE
	if ((err = rtnet_proc_register()) != 0)
		goto err_out2;
#endif

	/* initialize the Stack-Manager */
	if ((err = rt_stack_mgr_init(&STACK_manager)) != 0)
		goto err_out3;

	/* initialize the RTDEV-Manager */
	if ((err = rt_rtdev_mgr_init(&RTDEV_manager)) != 0)
		goto err_out4;

	rtnet_chrdev_init();

	if ((err = rtwlan_init()) != 0)
		goto err_out5;

	if ((err = rtpc_init()) != 0)
		goto err_out6;

	rtnet_corectl_register();

	return 0;

err_out6:
	rtwlan_exit();

err_out5:
	rtnet_chrdev_release();
	rt_rtdev_mgr_delete(&RTDEV_manager);

err_out4:
	rt_stack_mgr_delete(&STACK_manager);

err_out3:
#ifdef CONFIG_XENO_OPT_VFILE
	rtnet_proc_unregister();

err_out2:
#endif
	rtskb_pools_release();

err_out1:
	class_destroy(rtnet_class);

	return err;
}

/**
 *  rtnet_release()
 */
void __exit rtnet_release(void)
{
	rtnet_corectl_unregister();

	rtpc_cleanup();

	rtwlan_exit();

	rtnet_chrdev_release();

	rt_stack_mgr_delete(&STACK_manager);
	rt_rtdev_mgr_delete(&RTDEV_manager);

	rtskb_pools_release();

#ifdef CONFIG_XENO_OPT_VFILE
	rtnet_proc_unregister();
#endif

	class_destroy(rtnet_class);

	printk("RTnet: unloaded\n");
}

module_init(rtnet_init);
module_exit(rtnet_release);