#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <asm/uaccess.h>
#include <linux/uaccess.h>

#include "ip1811.h"
#include "ip1811fdat.h"

static struct cdev ip1811_cdev;
struct class *ip1811_class;
static DEFINE_MUTEX(ip1811_mutex);
u8 CPU_IF_SPEED_NORMAL;

#define	IP1811_MAJOR	248
#define IP1811_NAME	"ip1811_cdev"

//#define IP1811DEBUG

MODULE_LICENSE ("GPL");

static int ip1811_open(struct inode *inode, struct file *fs)
{
#ifdef IP1811DEBUG
	printk("ip1811: open...\n");
#endif
	try_module_get(THIS_MODULE);

	return 0;
}

static int ip1811_release(struct inode *inode, struct file *file)
{
	module_put(THIS_MODULE);
#ifdef IP1811DEBUG
	printk("ip1811: release!\n");
#endif
	return 0;
}

static ssize_t ip1811_read(struct file *filp, char __user *buffer, size_t length, loff_t *offset)
{
	//  	return simple_read_from_buffer(buffer, length, offset, msg, 200);
	return 0;
}

static ssize_t ip1811_write(struct file *filp, const char __user *buff, size_t len, loff_t *off)
{
	/*	if (len > 199)
		return -EINVAL;
		copy_from_user(msg, buff, len);
		msg[len] = '\0';
		return len;*/
	return 0;
}

static int ip1811_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
	int ret;
	unsigned long len, cmdid, fno, fsubg, fgrp, fusg;
	void *cptr;
	char *cdata, *cmptr;
	int offset_t;

#ifdef IP1811DEBUG
	printk(KERN_ALERT "ip1811: +ioctl...\n");
#endif
	len = (int)(_IOC_SIZE(cmd));
	cptr = (void *)arg;
	offset_t = sizeof(void*) + sizeof(unsigned long);

	do {
		cdata = kmalloc(len, GFP_KERNEL);
		cmptr=cdata;

		if (!cdata)
		{
			printk(KERN_ERR "cdata==NULL");
			ret = -ENOMEM;
			goto out_ip1811_ioctl;
		}

#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)
		if(access_ok(VERIFY_READ, cptr, len)){
#else
		if(access_ok(cptr, len)){
#endif
			if(copy_from_user(cdata, cptr, len)){
				printk(KERN_ERR "copy_from_user fail. len:%ld",(unsigned long)len);
				ret=-EFAULT;
				goto out_ip1811_ioctl;
			}
		}
		else{
			printk(KERN_ERR "[switchDriver] copy_from_user access fail by %s:%d CMD:%x\n",__FUNCTION__,__LINE__,cmd);
			ret = -EFAULT;
			goto out_ip1811_ioctl;
		}
		if(cmptr!=cdata){
			printk(KERN_ERR "cdata error org: %p, after: %p", cmptr, cdata);
		}
		cmdid = *((unsigned long *)(cdata+offset_t));
		fno = (cmdid >> _CMDID_NRSHIFT) & _CMDID_NRMASK;
		fsubg=(cmdid >> _CMDID_SUBGSHIFT) & _CMDID_SUBGMASK;
		fgrp= (cmdid >> _CMDID_GRPSHIFT) & _CMDID_GRPMASK;
		fusg= (cmdid >> _CMDID_USGSHIFT) & _CMDID_USGMASK;
#ifdef IP1811DEBUG
		printk(KERN_ALERT "cmdid=0x%08x\n", (unsigned int)cmdid);
#endif

		if (fusg == _CMDID_USG_COMMON)
		{
			switch (fgrp)
			{
				case _CMDID_GRP_BASIC:
					switch (fsubg)
					{
						case _CMDID_SUBG_SMI:
							ret = func_of_common_smi[fno](cdata, len);	break;

						case _CMDID_SUBG_CAP:
							ret = func_of_common_cap[fno](cdata, len);	break;

						case _CMDID_SUBG_LUT:
							ret = func_of_common_lut[fno](cdata, len);	break;

						case _CMDID_SUBG_SNIFFER:
							ret = func_of_common_sniffer[fno](cdata, len);	break;

						case _CMDID_SUBG_STORM:
							ret = func_of_common_storm[fno](cdata, len);	break;

						case _CMDID_SUBG_EOC:
							ret = func_of_common_eoc[fno](cdata, len);	break;

						case _CMDID_SUBG_LD:
							ret = func_of_common_ld[fno](cdata, len);	break;

						case _CMDID_SUBG_WOL:
							ret = func_of_common_wol[fno](cdata, len);	break;

						case _CMDID_SUBG_STAG:
							ret = func_of_common_stag[fno](cdata, len);	break;

						case _CMDID_SUB_BANDWIDTH:
							ret = func_of_common_bandwidth[fno](cdata, len);	break;

						case _CMDID_SUBG_MISC:
							ret = func_of_common_misc[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_VLAN:
					switch (fsubg)
					{
						case _CMDID_SUBG_VLAN:
							ret = func_of_common_vlan[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_QOS:
					switch (fsubg)
					{
						case _CMDID_SUB_BANDWIDTH:
							ret = func_of_common_bandwidth[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_SEC:
					switch (fsubg)
					{
						case _CMDID_SUBG_IMP:
							ret = func_of_common_imp[fno](cdata, len);	break;

						case _CMDID_SUBG_COS:
							ret = func_of_common_cos[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_ADV:
					switch (fsubg)
					{
						case _CMDID_SUBG_STP:
							ret = func_of_common_stp[fno](cdata, len);	break;

						case _CMDID_SUBG_LACP:
							ret = func_of_common_lacp[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				default:
					ret = -EINVAL;
			}
		}
		else if (fusg == _CMDID_USG_IP1811)
		{
			switch (fgrp)
			{
				case _CMDID_GRP_BASIC:
					switch (fsubg)
					{
						case _CMDID_SUBG_CAP:
							ret = func_of_common_cap[fno](cdata, len);	break;

						case _CMDID_SUBG_LUT:
							ret = func_of_ip1811_lut[fno](cdata, len);	break;

						case _CMDID_SUBG_SNIFFER:
							ret = func_of_ip1811_sniffer[fno](cdata, len);	break;

						case _CMDID_SUBG_STORM:
							ret = func_of_ip1811_storm[fno](cdata, len);	break;

						case _CMDID_SUBG_EOC:
							ret = func_of_ip1811_eoc[fno](cdata, len);	break;

						case _CMDID_SUBG_LD:
							ret = func_of_ip1811_ld[fno](cdata, len);	break;

						case _CMDID_SUBG_WOL:
							ret = func_of_ip1811_wol[fno](cdata, len);	break;

						case _CMDID_SUBG_IGMP:
							ret = func_of_ip1811_igmp[fno](cdata, len);	break;

						case _CMDID_SUBG_PTP:
							ret = func_of_ip1811_ptp[fno](cdata, len); break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_VLAN:
					switch (fsubg)
					{
						case _CMDID_SUBG_VLAN:
							ret = func_of_ip1811_vlan[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;
				case _CMDID_GRP_QOS:
					switch (fsubg)
					{
						case _CMDID_SUB_QOS:
							ret = func_of_ip1811_qos[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;
				case _CMDID_GRP_ACL:
					switch (fsubg)
					{
						case _CMDID_SUBG_ACL:
							ret = func_of_ip1811_acl[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_SEC:
					switch (fsubg)
					{
						case _CMDID_SUBG_IMP:
							ret = func_of_ip1811_imp[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_ADV:
					switch (fsubg)
					{
						case _CMDID_SUBG_STP:
							ret = func_of_ip1811_stp[fno](cdata, len);	break;

						case _CMDID_SUBG_LACP:
							ret = func_of_ip1811_lacp[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;
				case _CMDID_GRP_MON:
					switch (fsubg)
					{
						case _CMDID_SUBG_MIB_COUNTER:
							ret = func_of_ip1811_mib_counter[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				case _CMDID_GRP_HSR:
					switch (fsubg)
					{
						case _CMDID_SUBG_HSR:
							ret = func_of_ip1811_hsr[fno](cdata, len);	break;

						default:
							ret = -EINVAL;
					}
					break;

				default:
					ret = -EINVAL;
			}
		}
		else
			ret = -EINVAL;

		if (ret < 0)	goto out_ip1811_ioctl;
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)
		if(access_ok(WERIFY_WRITE, cptr, len)){
#else
		if(access_ok(cptr, len)){
#endif
			if (copy_to_user(cptr, cdata, len))	{
				printk(KERN_ERR "copy_touser fail.");
				ret = -EFAULT;
				goto out_ip1811_ioctl;
			}
		}
		else{
			printk(KERN_ERR "[switchDriver] copy_from_user access fail by %s:%d CMD:%x\n",__FUNCTION__,__LINE__,cmd);
			ret=-EFAULT;
			goto out_ip1811_ioctl;
		}
		cptr= (void *)*((unsigned long *)cdata);
		len = *((unsigned long *)(cdata+4));

		kfree(cdata);
		cdata = NULL;
	} while (cptr);
out_ip1811_ioctl:
	if(cdata)
	{
		//memset(cdata, 0x0, len);
		kfree(cdata);
	}
#ifdef IP1811DEBUG
	printk(KERN_ALERT "ip1811: -ioctl...\n");
#endif
	return (ret < 0) ? ret : 0;
}

static void lock_key_ioctl(void)
{
	mutex_lock(&ip1811_mutex);
}

static void unlock_key_ioctl(void)
{
	mutex_unlock(&ip1811_mutex);
}

static long ip1811_unlocked_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
	int ret;

	lock_key_ioctl();
	ret = ip1811_ioctl(filep, cmd, arg);
	unlock_key_ioctl();

	return ret;
}

static struct file_operations ip1811_fops = {
	.owner			= THIS_MODULE,
	.read			= ip1811_read,
	.write			= ip1811_write,
	.unlocked_ioctl	= ip1811_unlocked_ioctl,
	.open			= ip1811_open,
	.release		= ip1811_release
};

extern u16 Read_Reg(u8 regaddr);
extern void Write_Reg(u8 regaddr, u16 value);
extern void IP2Page(u8 page);
extern u16 Read_Reg_0_With_1s(void);

/* ==================================================================================== */

static int __init ip1811_init(void)
{
	int result;

	result = register_chrdev_region(MKDEV(IP1811_MAJOR, 0), 1, IP1811_NAME);
	if (result < 0)
	{
		printk(KERN_WARNING "ip1811: can't get major %d\n", IP1811_MAJOR);
		return result;
	}

	cdev_init(&ip1811_cdev, &ip1811_fops);
	ip1811_cdev.owner = THIS_MODULE;
	result = cdev_add(&ip1811_cdev, MKDEV(IP1811_MAJOR, 0), 1);
	if (result)
	{
		printk(KERN_WARNING "ip1811: error %d adding driver\n", result);
		return result;
	}

	CPU_IF_SPEED_NORMAL = 0; //set to normal speed initially

	IP2Page(0);
	if( (Read_Reg_0_With_1s() & 0xFFF0) == 0x8120 )
	{
		printk("ip1811: CPU I/F High speed.");
	}
	else
	{
		CPU_IF_SPEED_NORMAL = 1;
		printk("ip1811: CPU I/F Normal speed.");
	}
	
	// for acl_man init.
	acl_init();

	printk(" Driver loaded!\n");
	return 0;
	/*
fail_return:
	if(ip1811_cdev){
		cdev_del(ip1811_cdev);
		kfree(ip1811_cdev);
		ip1811_cdev=NULL;
	}
	if(devno)
		unregister_chrdev_region(devno, 1);
	if(ip1811_class)
		class_destroy(ip1811_class);
	return -1;
	*/
}

static void __exit ip1811_exit(void)
{
	/*
	if(ip1811_cdev){
		cdev_del(ip1811_cdev);
		kfree(ip1811_cdev);
		ip1811_cdev=NULL;
	}
	if(devno)
		unregister_chrdev_region(devno, 1);
	if(ip1811_class)
		class_destroy(ip1811_class);
	*/
	cdev_del(&ip1811_cdev);
	unregister_chrdev_region(MKDEV(IP1811_MAJOR, 0), 1);
	printk("ip1811: Driver unloaded!\n");
}

module_init(ip1811_init);
module_exit(ip1811_exit);