/**
 * (C) Copyright 2013 Quantenna Communications Inc.
 *
 * 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., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 **/

#include <linux/types.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/io.h>
#include <linux/igmp.h>
#include <linux/hardirq.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/ctype.h>
#include <linux/if_ether.h>
#include <linux/inet.h>
#include <linux/net/bridge/br_public.h>

#include <net80211/if_ethersubr.h>
#include <net80211/ieee80211.h>

#include <qtn/qtn_debug.h>
#include <qtn/qtn_uc_comm.h>
#include <qtn/qtn_net_packet.h>
#include <qtn/iputil.h>
#include <qtn/topaz_tqe_cpuif.h>
#include <qtn/topaz_fwt_cpuif.h>
#include <qtn/topaz_fwt_if.h>
#include <qtn/topaz_fwt_db.h>
#include <qtn/topaz_fwt.h>
#include <qtn/mproc_sync_base.h>

MODULE_DESCRIPTION("Forwarding Table Interface");
MODULE_AUTHOR("Quantenna Communications, Inc.");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0");

#define PROC_NAME "topaz_fwt_if"

/* Success definition in FWT Interface is return positive value */
#define FWT_IF_SUCCESS(x)	((x) >= 0)
/* Error definition in FWT Interface is return negative value */
#define FWT_IF_ERROR(x)		(!(FWT_IF_SUCCESS(x)))

/* specific commands keywords - must match fwt_if_usr_cmd */
#define FWT_IF_KEY_CLEAR		"clear"
#define FWT_IF_KEY_ON			"on"
#define FWT_IF_KEY_OFF			"off"
#define FWT_IF_KEY_PRINT		"print"
#define FWT_IF_KEY_ADD_STATIC_MC	"add_static_mc"
#define FWT_IF_KEY_DEL_STATIC_MC	"del_static_mc"
#define FWT_IF_KEY_GET_MC_LIST		"get_mc_list"
#define FWT_IF_KEY_ADD			"add"
#define FWT_IF_KEY_DELETE		"del"
#define FWT_IF_KEY_AUTO			"auto"
#define FWT_IF_KEY_MANUAL		"manual"
#define FWT_IF_KEY_NODE			"node"
#define FWT_IF_KEY_4ADDR		"4addr"
#define FWT_IF_KEY_HELP			"help"
#define FWT_IF_KEY_DEBUG		"debug"
#define FWT_IF_KEY_AGEING		"ageing"

/* additional keywords */
#define FWT_IF_KEY_PORT			"port"
#define FWT_IF_KEY_ENABLE		"enable"
#define FWT_IF_KEY_MAC			"mac"

#define PRINT_FWT(a...)		do { if (g_debug) { printk(a); } } while(0)

const char *g_port_names[] = TOPAZ_TQE_PORT_NAMES;
static fwt_if_sw_cmd_hook g_fwt_if_cmd_hook = NULL;
static char *fwt_if_outbuf = NULL;
static spinlock_t fwt_if_outbuf_lock;	/* synchronise use of fwt_if_outbuf */

/* set command keywords */
static char *fwt_str_cmd[FWT_IF_MAX_CMD] = {
		FWT_IF_KEY_CLEAR,
		FWT_IF_KEY_ON,
		FWT_IF_KEY_OFF,
		FWT_IF_KEY_PRINT,
		FWT_IF_KEY_ADD_STATIC_MC,
		FWT_IF_KEY_DEL_STATIC_MC,
		FWT_IF_KEY_GET_MC_LIST,
		FWT_IF_KEY_ADD,
		FWT_IF_KEY_DELETE,
		FWT_IF_KEY_AUTO,
		FWT_IF_KEY_MANUAL,
		FWT_IF_KEY_4ADDR,
		FWT_IF_KEY_DEBUG,
		FWT_IF_KEY_HELP,
		FWT_IF_KEY_AGEING,
};

/* value of extracted keywords from user */
typedef	enum {
	FWT_IF_ID,
	FWT_IF_MAC,
	FWT_IF_PORT,
	FWT_IF_NODE,
	FWT_IF_ENABLE,
	FWT_IF_VALUE,
	FWT_IF_MAX_PARAM,
} fwt_if_usr_str;

static inline int fwt_if_split_words(char **words, char *str)
{
	int word_count = 0;

	/* skip leading space */
	while (str && *str && isspace(*str)) {
		str++;
	}

	while (str && *str) {
		words[word_count++] = str;

		/* skip this word */
		while (str && *str && !isspace(*str)) {
			str++;
		}

		/* replace spaces with NULL */
		while (str && *str && isspace(*str)) {
			*str = 0;
			str++;
		}
	}

	return word_count;
}

static int inline fwt_if_set_sw_cmd(fwt_if_usr_cmd cmd, struct fwt_if_common *data)
{
	if (g_fwt_if_cmd_hook) {
		return g_fwt_if_cmd_hook(cmd, data);
	}

	return -1;
}

#if LINUX_VERSION_CODE < KERNEL_VERSION(4,6,3)
/* back-ported from Linux 3.14.24 net_utils.c */
static int mac_pton(const char *s, u8 *mac)
{
	int i;

	/* XX:XX:XX:XX:XX:XX */
	if (strlen(s) != (3 * ETH_ALEN - 1))
		return 0;

	/* Don't dirty result unless string is valid MAC. */
	for (i = 0; i < ETH_ALEN; i++) {
		if (!isxdigit(s[i * 3]) || !isxdigit(s[i * 3 + 1]))
			return 0;
		if (i != ETH_ALEN - 1 && s[i * 3 + 2] != ':')
			return 0;
	}
	for (i = 0; i < ETH_ALEN; i++) {
		mac[i] = (hex_to_bin(s[i * 3]) << 4) | hex_to_bin(s[i * 3 + 1]);
	}
	return 1;
}
#endif

static int fwt_if_extract_parm(char *str, fwt_if_usr_str cmd, void *var)
{
	struct fwt_if_id *id;
#ifdef CONFIG_IPV6
	uint8_t *ip6;
#endif
	uint8_t *ip4;
	uint8_t *mac;
	int i, node_num, param;
	uint8_t node[FWT_IF_USER_NODE_MAX];

	/* clear node array */
	memset(node, FWT_DB_INVALID_NODE, FWT_IF_USER_NODE_MAX);
	if (!str) {
		return -EINVAL;
	}

	switch (cmd) {
	case FWT_IF_MAC:
		id = var;
		mac = id->mac_be;
		if (!mac_pton(str, mac))
			return -EINVAL;
		break;
	case FWT_IF_ID:
		/*
		 * This keyword takes a MAC address or an IPv4 or IPv6 address. If it is a multicast
		 * IP address it is also converted into a multicast layer 2 (MAC) address.
		 */
		id = var;
#ifdef CONFIG_IPV6
		ip6 = id->ip.u.ip6.in6_u.u6_addr8;
#endif
		ip4 = (void *) &id->ip.u.ip4;
		mac = id->mac_be;
		id->ip.proto = 0;

#ifdef CONFIG_IPV6
		/* accept complete and compressed IPv6 addr notation */
		if (in6_pton(str, -1, ip6, -1, NULL)) {
			if (!ipv6_addr_is_multicast(&id->ip.u.ip6))
				return -EINVAL;
			id->ip.proto = htons(ETHERTYPE_IPV6);
			fwt_mcast_to_mac(mac, &id->ip);
		} else
#endif
		/* accept XX:XX:XX:XX:XX:XX ethernet addr notation */
		if (mac_pton(str, mac)) {
			/* MAC handling OK */
		}
		/* accept x.x.x.x IPv4 addr notation */
		else if (in4_pton(str, -1, ip4, -1, NULL)) {
			if (!ipv4_is_multicast(id->ip.u.ip4))
				return -EINVAL;
			id->ip.proto = htons(ETHERTYPE_IP);
			fwt_mcast_to_mac(mac, &id->ip);
		} else {
			return -EINVAL;
		}
		break;
	case FWT_IF_PORT:
		/* Port array names order correspond to HW port numbers */
		for (i = 0; i < TOPAZ_TQE_NUM_PORTS; i++) {
			if (strcmp(str, g_port_names[i]) == 0) {
				*((uint8_t*)var) = i;
				return 1;
			}
		}
		return -ENOENT;
		break;
	case FWT_IF_NODE:
		node_num = sscanf(str, "%hhu:%hhu:%hhu:%hhu:%hhu:%hhu",
						&node[0], &node[1], &node[2],
						&node[3], &node[4], &node[5]);
		if (node_num <= 0) {
			return -EINVAL;
		}

		for (i = 0; i < node_num; i++) {
			if (node[i] >= QTN_NCIDX_MAX) {
				return -EINVAL;
			}
		}
		memcpy(var, node, node_num * sizeof(uint8_t));
		break;
	case FWT_IF_ENABLE:
		sscanf(str, "%u", &param);
		if ( (param == 0) || (param == 1)) {
			*((uint32_t*)var) = param;
		} else {
			return -EINVAL;
		}
		break;
	case FWT_IF_VALUE:
		sscanf(str, "%d", &param);
		*((int32_t*)var) = param;
		break;
	default:
		return -EINVAL;
	}

	return 1;
}

/*
 * Get the current value that attached to keyword definition
 * @param str: the string to find keyword
 * @param words: the target search
 * @param word_count: number of words to search from
 * @return: the value as a string
 */
static char *fwt_if_get_val_from_keyword(char *str, char **words, uint8_t word_count)
{
	while (words && --word_count) {
		if (strcmp(str, *words) == 0) {
			/* return the value attached to the keyword */
			return *(++words);
		}
		/* advance to next word */
		words++;
	}
	return NULL;
}

static void fwt_if_apply_user_print_help(void)
{
	printk("FWT commands\n");
	printk("clear        remove all entries from the SW and HW FWT tables\n");
	printk("on           enable the FWT interface\n");
	printk("off          disable the FWT interface\n");
	printk("print        print the contents of the SW FWT\n");
	printk("add_static_mc <ip> mac <mac>\n");
	printk("             add a static multicast entry\n");
	printk("del_static_mc <ip> mac <mac>\n");
	printk("             delete a static multicast entry\n");
	printk("get_mc_list  return a list of multicast addresses\n");
	printk("add <mac> port <port> node <node>\n");
	printk("             add a unicast entry to the FWT\n");
	printk("             e.g. add 01:ab:ac:34:67:20 port wmac node 3\n");
	printk("add <ip> port <port> node <node>\n");
	printk("             add a multicast entry to the FWT\n");
	printk("             e.g. add 224.1.2.3 port wmac node 3\n");
	printk("del <mac>    delete a table entry by MAC address\n");
	printk("del <ip>     delete a table entry by IP address\n");
	printk("auto         enable automatic generation of table entries by the bridge module\n");
	printk("manual       enable manual-only creation of table entries, with no restrictions\n");
	printk("4addr <mac> enable {0|1}\n");
	printk("             enable or disable 4-address support for a MAC address\n");
	printk("debug {0|1}  enable or disable debug messages\n");
	printk("ageing {0|1} enable or disable table entry ageing\n");
	printk("help         print this\n");
}
static int fwt_if_apply_user_debug_mode(char **words, uint8_t word_count)
{
	char *str_val;
	int rc;
	struct fwt_if_common data;

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_DEBUG, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ENABLE, &data.param);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}
	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_DEBUG, &data);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	return 1;
}

static int fwt_if_apply_user_ageing(char **words, uint8_t word_count)
{
	char *str_val;
	int rc;
	struct fwt_if_common data;

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_AGEING, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ENABLE, &data.param);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}
	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_AGEING, &data);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	return 1;
}

static int fwt_if_apply_user_4addr_mode(char **words, uint8_t word_count)
{
	char *str_val;
	int rc;
	struct fwt_if_common data;

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_4ADDR, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ID, &data.id);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}
	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_ENABLE, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ENABLE, &data.param);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}
	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_4ADDR, &data);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	return 1;
}

static int fwt_if_apply_user_del_entry(char **words, uint8_t word_count)
{
	int rc;
	struct fwt_if_common data;
	char *str_val;

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_DELETE, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ID, &data.id);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}
	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_DELETE, &data);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}
	return 1;
}

static int fwt_if_apply_user_add_entry(char **words, uint8_t word_count)
{
	int rc;
	char *str_val = NULL;
	struct fwt_if_common data;

	memset(data.node, FWT_DB_INVALID_NODE, sizeof(data.node));

	/* ADD example: "add ab:34:be:af:34:42 port lhost node 2:4:3" */
	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_ADD, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ID, &data.id);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_PORT, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_PORT, &data.port);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_NODE, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_NODE, &data.node);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_ADD, &data);
	if (FWT_IF_ERROR(rc)) {
		return rc;
	}

	return 1;
}

static int fwt_if_apply_user_add_static_mc(char **words, uint8_t word_count)
{
	int rc;
	char *str_val = NULL;
	struct fwt_if_common data;
	struct fwt_if_id *id = &data.id;

	memset(data.node, FWT_DB_INVALID_NODE, sizeof(data.node));

	/* ADD_STATIC_MC example: "add_static_mc 224.51.2.3 mac ab:34:be:af:34:42*/
	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_ADD_STATIC_MC, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ID, id);
	if (FWT_IF_ERROR(rc))
		return rc;

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_MAC, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_MAC, id);
	if (FWT_IF_ERROR(rc))
		return rc;

	switch (id->ip.proto) {
	case htons(ETHERTYPE_IP):
		if (!IPUTIL_V4_ADDR_MULTICAST(id->ip.u.ip4))
			return -EINVAL;
		break;
#ifdef CONFIG_IPV6
	case htons(ETHERTYPE_IPV6):
		if (!IPUTIL_V6_ADDR_MULTICAST(*id->ip.u.ip6.in6_u.u6_addr16))
			return -EINVAL;
		break;
#endif
	default:
		return -EINVAL;
	}

	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_ADD_STATIC_MC, &data);
	if (FWT_IF_ERROR(rc))
		return rc;

	return 1;
}

static int fwt_if_apply_user_del_static_mc(char **words, uint8_t word_count)
{
	int rc;
	char *str_val = NULL;
	struct fwt_if_common data;
	struct fwt_if_id *id = &data.id;

	memset(data.node, FWT_DB_INVALID_NODE, sizeof(data.node));

	/* DEL_STATIC_MC example: "del_static_mc 224.51.2.3 mac ab:34:be:af:34:42*/
	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_DEL_STATIC_MC, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_ID, id);
	if (FWT_IF_ERROR(rc))
		return rc;

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_MAC, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_MAC, id);
	if (FWT_IF_ERROR(rc))
		return rc;

	switch (id->ip.proto) {
	case htons(ETHERTYPE_IP):
		if (!IPUTIL_V4_ADDR_MULTICAST(id->ip.u.ip4))
			return -EINVAL;
		break;
#ifdef CONFIG_IPV6
	case htons(ETHERTYPE_IPV6):
		if (!IPUTIL_V6_ADDR_MULTICAST(*id->ip.u.ip6.in6_u.u6_addr16))
			return -EINVAL;
		break;
#endif
	default:
		return -EINVAL;
	}

	rc = fwt_if_set_sw_cmd(FWT_IF_CMD_DEL_STATIC_MC, &data);
	if (FWT_IF_ERROR(rc))
		return rc;

	return 1;
}

#define FWT_IF_OUTBUF_LEN_MIN	32
#define FWT_IF_OUTBUF_LEN_MAX	8192

/* Must be called with the fwt_if_outbuf_lock held */
static int fwt_if_get_mc_list(char **words, uint8_t word_count)
{
	int rc;
	struct fwt_if_common data;
	char *str_val = NULL;

	if (fwt_if_outbuf) {
		/* a command was issued previously but the output was not retrieved */
		kfree(fwt_if_outbuf);
		fwt_if_outbuf = NULL;
	}

	str_val = fwt_if_get_val_from_keyword(FWT_IF_KEY_GET_MC_LIST, words, word_count);
	rc = fwt_if_extract_parm(str_val, FWT_IF_VALUE, &data.param);
	if (FWT_IF_ERROR(rc))
		return rc;

	if (data.param <= FWT_IF_OUTBUF_LEN_MIN || data.param > FWT_IF_OUTBUF_LEN_MAX)
		return -EINVAL;

	fwt_if_outbuf = kmalloc(data.param, GFP_KERNEL);
	if (!fwt_if_outbuf)
		return -ENOMEM;

	memset(fwt_if_outbuf, 0, data.param);
	data.extra = fwt_if_outbuf;

	fwt_if_set_sw_cmd(FWT_IF_CMD_GET_MC_LIST, &data);

	return 1;
}

/* Apply user command.
 * User command can control the FWT interface.
 * @param cmd_num: command number
 * @param words: the split words without spaces from the user space console interface
 * @param word_count: number of words after split
 * @return: status indication
 */
static int fwt_if_apply_user_command(fwt_if_usr_cmd cmd_num, char **words, uint8_t word_count)
{
	int rc = -EINVAL;
	struct fwt_if_common data;

	if ((word_count == 0) || (!words))
		goto cmd_failure;

	memset(&data, 0, sizeof(data));

	switch(cmd_num) {
		case FWT_IF_CMD_CLEAR:
		case FWT_IF_CMD_ON:
		case FWT_IF_CMD_OFF:
		case FWT_IF_CMD_PRINT:
		case FWT_IF_CMD_AUTO:
		case FWT_IF_CMD_MANUAL:
			rc = fwt_if_set_sw_cmd(cmd_num, &data);
			break;
		case FWT_IF_CMD_GET_MC_LIST:
			spin_lock(&fwt_if_outbuf_lock);
			rc = fwt_if_get_mc_list(words, word_count);
			spin_unlock(&fwt_if_outbuf_lock);
			break;
		case FWT_IF_CMD_ADD:
			rc = fwt_if_apply_user_add_entry(words, word_count);
			break;
		case FWT_IF_CMD_DELETE:
			/* Delete example: "del ab:34:be:af:34:42" */
			rc = fwt_if_apply_user_del_entry(words, word_count);
			break;
		case FWT_IF_CMD_ADD_STATIC_MC:
			rc = fwt_if_apply_user_add_static_mc(words, word_count);
			break;
		case FWT_IF_CMD_DEL_STATIC_MC:
			rc = fwt_if_apply_user_del_static_mc(words, word_count);
			break;
		case FWT_IF_CMD_4ADDR:
			rc = fwt_if_apply_user_4addr_mode(words, word_count);
			break;
		case FWT_IF_CMD_DEBUG:
			rc = fwt_if_apply_user_debug_mode(words, word_count);
			break;
		case FWT_IF_CMD_AGEING:
			rc = fwt_if_apply_user_ageing(words, word_count);
			break;
		case FWT_IF_CMD_HELP:
			rc = 0;
			fwt_if_apply_user_print_help();
			break;
		default:
			goto cmd_failure;
		break;
	}

	if (FWT_IF_ERROR(rc))
		goto cmd_failure;

	return 1;

cmd_failure:
	if (word_count)
		printk(KERN_INFO "Failed to parse command: %s\n", *words);
	else
		fwt_if_apply_user_print_help();

	return -EPERM;
}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0)
static ssize_t fwt_if_write_proc(struct file *file, const char __user *buffer,
				size_t count, loff_t *f_pos)
#else
static int fwt_if_write_proc(struct file *file, const char __user *buffer,
				unsigned long count, void *data)
#endif
{
	char *cmd;
	int i;
	char **words;
	uint8_t word_count;
	fwt_if_usr_cmd cmd_num = 0;

	cmd = kzalloc(count, GFP_KERNEL);
	words = kzalloc(count * sizeof(char *) / 2, GFP_KERNEL);
	if (!cmd || !words)
		goto out;

	if (copy_from_user(cmd, buffer, count))
		goto out;

	cmd[count - 1] = '\0';

	word_count = fwt_if_split_words(words, cmd);
	if (!word_count)
		goto out;

	for (i = 0; i < FWT_IF_MAX_CMD; i++, cmd_num++) {
		if (strcmp(words[0], fwt_str_cmd[i]) == 0)
			break;
	}

	local_bh_disable();

	fwt_if_apply_user_command(cmd_num, words, word_count);

	local_bh_enable();

out:
	kfree(cmd);
	kfree(words);

	return count;
}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0)
//TODO: As of now just signature has matched; need to enhance further
static int fwt_if_show(struct seq_file *seq, void *v)
{
	int class_id = (int)seq->private;

	seq_printf(seq, "class=%d, level=%d\n", class_id, class_id);
	return 0;
}

static int fwt_if_open_proc(struct inode *inode, struct file *file)
{
	return single_open(file, fwt_if_show, PDE_DATA(inode));
}

static const struct file_operations fwt_if_fops = {
	.owner = THIS_MODULE,
	.open = fwt_if_open_proc,
	.write = fwt_if_write_proc,
	.read = seq_read,
};
#else
static int fwt_if_read_proc(char *page, char **start, off_t off, int count, int *eof, void *_unused)
{
	int printed = 0;

	spin_lock(&fwt_if_outbuf_lock);

	if (fwt_if_outbuf) {
		printed = strnlen(fwt_if_outbuf, count - 1);
		strncpy(page, fwt_if_outbuf, printed);
		kfree(fwt_if_outbuf);
		fwt_if_outbuf = NULL;
	} else {
		page[0] = '\0';
	}

	spin_unlock(&fwt_if_outbuf_lock);

	page[count - 1] = '\0';
	*eof = 1;

	return printed;
}

#endif


void fwt_if_register_cbk_t(fwt_if_sw_cmd_hook cbk_func)
{
	g_fwt_if_cmd_hook = cbk_func;
}
EXPORT_SYMBOL(fwt_if_register_cbk_t);

static void __exit fwt_if_exit(void)
{
	remove_proc_entry(PROC_NAME, NULL);
}

static int __init topaz_fwt_if_create_proc(void)
{
	struct proc_dir_entry *entry;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0)
	entry = proc_create_data(PROC_NAME, 0600, NULL, &fwt_if_fops, NULL);
	if (!entry) {
		return -ENODEV;
	}
#else
	entry = = create_proc_entry(PROC_NAME, 0600, NULL);
	if (!entry) {
		return -ENODEV;
	}

	entry->write_proc = fwt_if_write_proc;
	entry->read_proc = fwt_if_read_proc;
#endif
	return 0;
}

static int __init fwt_if_init(void)
{
	int rc;

	rc = topaz_fwt_if_create_proc();
	if (rc)
		return rc;

	spin_lock_init(&fwt_if_outbuf_lock);

	return 0;
}
module_init(fwt_if_init);
module_exit(fwt_if_exit);