/*
 * A hwmon driver for the CIG cs6436-54P CPLD
 *
 * Copyright (C) 2018 Cambridge, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/wait.h>
#include <linux/isa.h>
#include <linux/i2c.h>
#include <linux/io.h>
#include <asm/irq.h>
#include "i2c-algo-lpc.h"
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <linux/i2c-mux.h>
#include <linux/list.h>
#include <linux/dmi.h>
#include <linux/dma-mapping.h>

#ifndef CPLD_USER
# include <linux/ioctl.h>
#else
# include <sys/ioctl.h>
#endif

#include <linux/input.h>
#include <linux/of_device.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <net/sock.h>
#include <linux/netlink.h>
#include <linux/rtc.h>





/**********************************************   Start  ********************************************************/

/*
 * ISA bus.
 */

static void platform_isa_bus_release(struct device * dev)
{
    return ;
}


static struct device isa_bus = {
	.init_name	= "lpc-isa",
    .release = platform_isa_bus_release,
};

struct isa_dev {
	struct device dev;
	struct device *next;
	unsigned int id;
};

#define to_isa_dev(x) container_of((x), struct isa_dev, dev)

static int isa_bus_match(struct device *dev, struct device_driver *driver)
{
	struct isa_driver *isa_driver = to_isa_driver(driver);

	if (dev->platform_data == isa_driver) {
		if (!isa_driver->match ||
			isa_driver->match(dev, to_isa_dev(dev)->id))
			return 1;
		dev->platform_data = NULL;
	}
	return 0;
}

static int isa_bus_probe(struct device *dev)
{
	struct isa_driver *isa_driver = dev->platform_data;

	if (isa_driver->probe)
		return isa_driver->probe(dev, to_isa_dev(dev)->id);

	return 0;
}

static int isa_bus_remove(struct device *dev)
{
	struct isa_driver *isa_driver = dev->platform_data;

	if (isa_driver->remove)
		return isa_driver->remove(dev, to_isa_dev(dev)->id);

	return 0;
}

static void isa_bus_shutdown(struct device *dev)
{
	struct isa_driver *isa_driver = dev->platform_data;

	if (isa_driver->shutdown)
		isa_driver->shutdown(dev, to_isa_dev(dev)->id);
}

static int isa_bus_suspend(struct device *dev, pm_message_t state)
{
	struct isa_driver *isa_driver = dev->platform_data;

	if (isa_driver->suspend)
		return isa_driver->suspend(dev, to_isa_dev(dev)->id, state);

	return 0;
}

static int isa_bus_resume(struct device *dev)
{
	struct isa_driver *isa_driver = dev->platform_data;

	if (isa_driver->resume)
		return isa_driver->resume(dev, to_isa_dev(dev)->id);

	return 0;
}

static struct bus_type isa_bus_type = {
	.name		= "lpc-isa",
	.match		= isa_bus_match,
	.probe		= isa_bus_probe,
	.remove 	= isa_bus_remove,
	.shutdown	= isa_bus_shutdown,
	.suspend	= isa_bus_suspend,
	.resume 	= isa_bus_resume
};

static void isa_dev_release(struct device *dev)
{
	kfree(to_isa_dev(dev));
}

void lpc_unregister_driver(struct isa_driver *isa_driver)
{
	struct device *dev = isa_driver->devices;

	while (dev) {
		struct device *tmp = to_isa_dev(dev)->next;
		device_unregister(dev);
		dev = tmp;
	}
	driver_unregister(&isa_driver->driver);
}


int lpc_register_driver(struct isa_driver *isa_driver, unsigned int ndev)
{
	int error;
	unsigned int id;

	isa_driver->driver.bus	= &isa_bus_type;
	isa_driver->devices = NULL;

	error = driver_register(&isa_driver->driver);
	if (error)
		return error;

	for (id = 0; id < ndev; id++) {
		struct isa_dev *isa_dev;

		isa_dev = kzalloc(sizeof *isa_dev, GFP_KERNEL);
		if (!isa_dev) {
			error = -ENOMEM;
			break;
		}

		isa_dev->dev.parent = &isa_bus;
		isa_dev->dev.bus	= &isa_bus_type;

		dev_set_name(&isa_dev->dev, "%s.%u",
				 isa_driver->driver.name, id);
		isa_dev->dev.platform_data	= isa_driver;
		isa_dev->dev.release		= isa_dev_release;
		isa_dev->id 		= id;

		isa_dev->dev.coherent_dma_mask = DMA_BIT_MASK(24);
		isa_dev->dev.dma_mask = &isa_dev->dev.coherent_dma_mask;

		error = device_register(&isa_dev->dev);
		if (error) {
			put_device(&isa_dev->dev);
			break;
		}

		if (isa_dev->dev.platform_data) {
			isa_dev->next = isa_driver->devices;
			isa_driver->devices = &isa_dev->dev;
		} else
			device_unregister(&isa_dev->dev);
	}

	if (!error && !isa_driver->devices)
		error = -ENODEV;

	if (error)
		isa_unregister_driver(isa_driver);

	return error;
}


int lpc_bus_init(void)
{
	int error;

	error = bus_register(&isa_bus_type);
	if (!error) {
		error = device_register(&isa_bus);
		if (error)
			bus_unregister(&isa_bus_type);
	}
	return error;
}

void lpc_bus_exit(void)
{

   device_unregister(&isa_bus);

   bus_unregister(&isa_bus_type);
}


/**********************************************   End  ********************************************************/






/**********************************************   Start  ********************************************************/
/*
 * module parameters:
 */
static int i2c_debug = 0;
static struct mutex	lpc_lock;


#define DEB2(x) if (i2c_debug == 2) x
#define DEB3(x) if (i2c_debug == 3) x
    /* print several statistical values */
#define DEBPROTO(x) if (i2c_debug == 9) x;
	/* debug the protocol by showing transferred bits */
#define DEF_TIMEOUT 160



/* setting states on the bus with the right timing: */

#define set_lpc(adap, ctl, val) adap->setlpc(adap->data, ctl, val)
#define get_lpc(adap, ctl) adap->getlpc(adap->data, ctl)
#define get_own(adap) adap->getown(adap->data)
#define get_clock(adap) adap->getclock(adap->data)
#define i2c_outaddr(adap, val) adap->setlpc(adap->data, I2C_LPC_REG_DEVICE_ADDR, val)

#define i2c_outbyte1(adap, val) adap->setlpc(adap->data, I2C_LPC_REG_DATA_TX1, val)
#define i2c_outbyte2(adap, val) adap->setlpc(adap->data, I2C_LPC_REG_DATA_TX2, val)
#define i2c_outbyte3(adap, val) adap->setlpc(adap->data, I2C_LPC_REG_DATA_TX3, val)
#define i2c_outbyte4(adap, val) adap->setlpc(adap->data, I2C_LPC_REG_DATA_TX4, val)
#define i2c_inbyte1(adap) adap->getlpc(adap->data, I2C_LPC_REG_DATA_RX1)
#define i2c_inbyte2(adap) adap->getlpc(adap->data, I2C_LPC_REG_DATA_RX2)
#define i2c_inbyte3(adap) adap->getlpc(adap->data, I2C_LPC_REG_DATA_RX3)
#define i2c_inbyte4(adap) adap->getlpc(adap->data, I2C_LPC_REG_DATA_RX4)



#define LPC_FPRINTF_LOG_PATH "/tmp/file.log"
struct file *lpc_fprintf_file = NULL;

static int lpc_fprintf_debug(const char *fmt, ...)
{
	char lpc_fprintf_buf[256]={0};
	struct va_format vaf;
	va_list args;
	int r;
	mm_segment_t old_fs;
	struct timeval tv;
	struct rtc_time tm;

    do_gettimeofday(&tv);

	rtc_time_to_tm(tv.tv_sec,&tm);

	va_start(args, fmt);
	vaf.fmt = fmt;
	vaf.va = &args;
	r=snprintf(lpc_fprintf_buf,sizeof(lpc_fprintf_buf),"[%04d.%08d] %pV\n",tm.tm_sec, (int)tv.tv_usec, &vaf);
	va_end(args);
	old_fs = get_fs();
	set_fs(KERNEL_DS);
	vfs_write(lpc_fprintf_file, (char *)&lpc_fprintf_buf, strlen(lpc_fprintf_buf), &lpc_fprintf_file->f_pos);
	set_fs(old_fs);
	memset(lpc_fprintf_buf,0x0,sizeof(lpc_fprintf_buf));
	return r;

}



static int lpc_fprintf_init(void)
{
	printk("lpc_fprintf_init.\n");

	if(lpc_fprintf_file == NULL)
		lpc_fprintf_file = filp_open(LPC_FPRINTF_LOG_PATH, O_RDWR | O_APPEND | O_CREAT, 0644);

	if (IS_ERR(lpc_fprintf_file)) {
		printk("Error occured while opening file %s, exiting...\n", LPC_FPRINTF_LOG_PATH);
		return -1;
	}

	return 0;
}

static int lpc_fprintf_exit(void)
{
	printk("lpc_fprintf_exit.\n");

	if(lpc_fprintf_file != NULL)
		filp_close(lpc_fprintf_file, NULL);

	return 0;
}


/* other auxiliary functions */


void print_reg(struct i2c_algo_lpc_data *adap)
{
	unsigned char status;
	DEBPROTO(lpc_fprintf_debug("================================================\n");)
	status = get_lpc(adap, I2C_LPC_REG_BUS_SEL);
	DEBPROTO(lpc_fprintf_debug("%s select reg %x : %x\n",__func__,I2C_LPC_REG_BUS_SEL, status);)
	status = get_lpc(adap, I2C_LPC_REG_BYTE_COUNT);
	DEBPROTO(lpc_fprintf_debug("%s count reg %x : %x\n",__func__,I2C_LPC_REG_BYTE_COUNT, status);)

	status = get_lpc(adap, I2C_LPC_REG_COMMAND);
	DEBPROTO(lpc_fprintf_debug("%s command reg %x : %x\n",__func__,I2C_LPC_REG_COMMAND, status);)
	status = get_lpc(adap, I2C_LPC_REG_DEVICE_ADDR);
	DEBPROTO(lpc_fprintf_debug("%s address reg %x : %x\n",__func__,I2C_LPC_REG_DEVICE_ADDR, status);)

	status = get_lpc(adap, I2C_LPC_REG_STATUS);
	DEBPROTO(lpc_fprintf_debug("%s status reg %x : %x\n",__func__,I2C_LPC_REG_STATUS, status);)
}



static void i2c_repstart(struct i2c_algo_lpc_data *adap)
{
	DEBPROTO(lpc_fprintf_debug("%s :\n",__func__);)
	set_lpc(adap, I2C_LPC_REG_COMMAND, I2C_LPC_REPSTART);
}

static void i2c_stop(struct i2c_algo_lpc_data *adap)
{
	DEBPROTO(lpc_fprintf_debug("%s :\n",__func__);)
	set_lpc(adap, I2C_LPC_REG_COMMAND, I2C_LPC_STOP);
	udelay(60);
	set_lpc(adap, I2C_LPC_REG_COMMAND, 0x00);
}




static void i2c_start(struct i2c_algo_lpc_data *adap)
{
	print_reg(adap);

	set_lpc(adap, I2C_LPC_REG_COMMAND, I2C_LPC_START);

	print_reg(adap);
}




static int wait_for_bb(struct i2c_algo_lpc_data *adap)
{

	int timeout = DEF_TIMEOUT;
	int status;

	while (--timeout) {
		status = get_lpc(adap, I2C_LPC_REG_STATUS);

		DEBPROTO(lpc_fprintf_debug("%s : Waiting for bus free status : %x\n",__func__,status);)

		if(status == I2C_LPC_TD)
		{
			DEBPROTO(lpc_fprintf_debug("%s : Bus is free status : %x\n",__func__,status);)
			break;
		}
	}

	if (timeout == 0) {
		DEBPROTO(lpc_fprintf_debug("%s : Timeout for free busy status : %x\n",__func__,status);)
		return -ETIMEDOUT;
	}



	return 0;
}


static int wait_for_be(int mode,struct i2c_algo_lpc_data *adap)
{

	int timeout = DEF_TIMEOUT;
	unsigned char status;


	while (--timeout) {

		status = get_lpc(adap, I2C_LPC_REG_STATUS);

		DEBPROTO(lpc_fprintf_debug("%s : Waiting for bus empty status : %x\n",__func__,status);)

		if(mode == 1)
		{
			if((status & I2C_LPC_IBB) && (status & I2C_LPC_TBE))
			{
				DEBPROTO(lpc_fprintf_debug("%s : Bus is empty status : %x\n",__func__,status);)
				break;
			}
		}
		else
		{
			if(status & I2C_LPC_TD)
			{
				DEBPROTO(lpc_fprintf_debug("%s : Bus is empty status : %x\n",__func__,status);)
				break;
			}
		}

		status = get_lpc(adap, I2C_LPC_REG_TEST);

		DEBPROTO(lpc_fprintf_debug("%s : The test register data : %x\n",__func__,status);)
		udelay(1); /* wait for 100 us */
	}

	if (timeout == 0) {
		DEBPROTO(lpc_fprintf_debug("%s : Timeout waiting for Bus Empty\n",__func__);)
		return -ETIMEDOUT;
	}

	return 0;
}


static int wait_for_bf(struct i2c_algo_lpc_data *adap)
{

	int timeout = DEF_TIMEOUT;
	int status;


	while (--timeout) {
		status = get_lpc(adap, I2C_LPC_REG_STATUS);

		DEBPROTO(lpc_fprintf_debug("%s : Waiting for bus full status : %x\n",__func__,status);)

		if(status & I2C_LPC_RBF)
		{
			DEBPROTO(lpc_fprintf_debug("%s : Bus is full status : %x\n",__func__,status);)
			break;
		}

		status = get_lpc(adap, I2C_LPC_REG_TEST);

		DEBPROTO(lpc_fprintf_debug("%s : The test register data : %x\n",__func__,status);)
		udelay(1); /* wait for 100 us */
	}

	if (timeout == 0) {
		DEBPROTO(lpc_fprintf_debug("%s : Timeout waiting for Bus Full\n",__func__);)
		return -ETIMEDOUT;
	}

	return 0;
}

static int wait_for_td(struct i2c_algo_lpc_data *adap)
{

	int timeout = DEF_TIMEOUT;
	int status=0;

	while (--timeout) {
		udelay(4);
		status = get_lpc(adap, I2C_LPC_REG_STATUS);

		DEBPROTO(lpc_fprintf_debug("%s : Waiting for bus done status : %x\n",__func__,status);)

		if(status == I2C_LPC_TD)
		{
			DEBPROTO(lpc_fprintf_debug("%s : Bus is done status : %x\n",__func__,status);)
			break;
		}
	}

	if (timeout == 0) {
		DEBPROTO(lpc_fprintf_debug("%s : Timeout waiting for Bus Done\n",__func__);)
		return -ETIMEDOUT;
	}

	return 0;
}



static int wait_for_pin(struct i2c_algo_lpc_data *adap, int *status)
{
	int timeout = DEF_TIMEOUT;
	*status = get_lpc(adap, I2C_LPC_REG_STATUS);

	while ((*status & I2C_LPC_TBE) && --timeout) {
		*status = get_lpc(adap, I2C_LPC_REG_STATUS);
	}

	if (timeout == 0)
		return -ETIMEDOUT;


	return 0;
}


static int lpc_doAddress(struct i2c_algo_lpc_data *adap,struct i2c_msg *msg)
{
	unsigned short flags = msg->flags;
	unsigned char addr;

	addr = msg->addr << 1;
	if (flags & I2C_M_RD)
	{
		addr |= 1;
		DEBPROTO(lpc_fprintf_debug("step 7 : read mode then write device address 0x%x\n",addr);)
	}
	else
	{
		DEBPROTO(lpc_fprintf_debug("step 2 : write mode then write device address 0x%x\n",addr);)
	}

	if (flags & I2C_M_REV_DIR_ADDR)
	{
		addr ^= 1;

	}
	i2c_outaddr(adap, addr);
	return 0;

}


static int lpc_sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
{
	struct i2c_algo_lpc_data *adap = i2c_adap->algo_data;
	int i = 0,timeout=0;

	unsigned int count = msg->len;
	unsigned char *buf = msg->buf;

	do{
		lpc_doAddress(adap,msg);
		set_lpc(adap, I2C_LPC_REG_BYTE_COUNT, (count-i) >= 4 ? 4:(count - i));
		DEBPROTO(lpc_fprintf_debug("step 3 : write register count %x\n",count);)

		if((count -i) >= 4)
		{
			i2c_outbyte1(adap, buf[i+0] & 0xff);
			i2c_outbyte2(adap, buf[i+1] & 0xff);
			i2c_outbyte3(adap, buf[i+2] & 0xff);
			i2c_outbyte4(adap, buf[i+3] & 0xff);

			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+0,buf[i+0]);)
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+1,buf[i+1]);)
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+2,buf[i+2]);)
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+3,buf[i+3]);)
			i += 4;
		}
		else if((count -i) == 3)
		{
			i2c_outbyte1(adap, buf[i+0] & 0xff);
			i2c_outbyte2(adap, buf[i+1] & 0xff);
			i2c_outbyte3(adap, buf[i+2] & 0xff);

			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+0,buf[i+0]);)
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+1,buf[i+1]);)
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+2,buf[i+2]);)

			i += 3;
		}
		else if((count -i) == 2)
		{
			i2c_outbyte1(adap, buf[i+0] & 0xff);
			i2c_outbyte2(adap, buf[i+1] & 0xff);
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+0,buf[i+0]);)
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+1,buf[i+1]);)
			i += 2;
		}
		else if((count -i) == 1)
		{
			i2c_outbyte1(adap, buf[i+0] & 0xff);
			DEBPROTO(lpc_fprintf_debug("step 4 : Send data[%d] = %x\n",i+0,buf[i+0]);)
			i += 1;
		}

		/* Send START */
		DEBPROTO(lpc_fprintf_debug("step 5-1 : Delay 6mS \n");)
		udelay(6000);
		DEBPROTO(lpc_fprintf_debug("step 5-2 : Start to transfrom \n");)
		i2c_stop(adap);
		i2c_start(adap);
		DEBPROTO(lpc_fprintf_debug("step 5-3 : Start done\n");)

		udelay(400);
		DEBPROTO(lpc_fprintf_debug("step 6 : Waiting for BE\n");)
		timeout = wait_for_td(adap);
		if (timeout) {
			DEBPROTO(lpc_fprintf_debug("step 6 : Timeout waiting for BE \n");)
			return -EREMOTEIO;
		}
	}while (i < count);

	if(i == count)
	{
		DEBPROTO(lpc_fprintf_debug("Writen %d bytes successd !\n",count);)
		return i;
	}
	else
	{
		DEBPROTO(lpc_fprintf_debug("Writen %d bytes failed \n",count);)
		return -EIO;
	}
}

static int lpc_readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
{
	int i=0,timeout=0;
	struct i2c_algo_lpc_data *adap = i2c_adap->algo_data;

	unsigned int count = msg->len;
	unsigned char *buf = msg->buf;

	do{
		lpc_doAddress(adap,msg);
		set_lpc(adap, I2C_LPC_REG_BYTE_COUNT, (count-i) >= 4 ? 4:(count - i));
		DEBPROTO(lpc_fprintf_debug("step 8 : write register count %d\n",count);)

		/* Send START */
		DEBPROTO(lpc_fprintf_debug("step 9-1 : Delay 6mS\n");)
		udelay(6000);
		DEBPROTO(lpc_fprintf_debug("step 9-2 : Start to receive data\n");)
		i2c_stop(adap);
		i2c_start(adap);
		DEBPROTO(lpc_fprintf_debug("step 9-3 : Start done\n");)

		udelay(400);
		DEBPROTO(lpc_fprintf_debug("step 10 : Waiting for TD\n");)
		timeout = wait_for_td(adap);
		if (timeout) {
			DEBPROTO(lpc_fprintf_debug("step 10 : Timeout waiting for TD \n");)
			return -EREMOTEIO;
		}

		if((count -i) >= 4)
		{
			buf[i+0] = 0xff & i2c_inbyte1(adap);
			buf[i+1] = 0xff & i2c_inbyte2(adap);
			buf[i+2] = 0xff & i2c_inbyte3(adap);
			buf[i+3] = 0xff & i2c_inbyte4(adap);

			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+0,buf[i+0]);)
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+1,buf[i+1]);)
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+2,buf[i+2]);)
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+3,buf[i+3]);)

			i += 4;
		}
		else if((count -i) == 3)
		{
			buf[i+0] = 0xff & i2c_inbyte1(adap);
			buf[i+1] = 0xff & i2c_inbyte2(adap);
			buf[i+2] = 0xff & i2c_inbyte3(adap);

			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+0,buf[i+0]);)
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+1,buf[i+1]);)
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+2,buf[i+2]);)

			i += 3;
		}
		else if((count -i) == 2)
		{
			buf[i+0] = 0xff & i2c_inbyte1(adap);
			buf[i+1] = 0xff & i2c_inbyte2(adap);
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+0,buf[i+0]);)
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+1,buf[i+1]);)
			i += 2;
		}
		else if((count -i) == 1)
		{
			buf[i+0] = 0xff & i2c_inbyte1(adap);
			DEBPROTO(lpc_fprintf_debug("step 11 : Receive data[%d] = %x\n",i+0,buf[i+0]);)
			i += 1;
		}


	}while(i < count);

	if(i == count)
	{
		DEBPROTO(lpc_fprintf_debug("Read %d bytes successd !\n",count);)
		return i;
	}
	else
	{
		DEBPROTO(lpc_fprintf_debug("Read %d bytes failed \n",count);)
		return -EIO;
	}
}


struct cpld_client_node {
	struct i2c_client *client;
	struct list_head   list;
};
#define LPC_I2C_MAX_NCHANS 6


struct lpc_iic {
	struct i2c_adapter *virt_adaps[LPC_I2C_MAX_NCHANS];
	u8 last_chan;		/* last register value */
};


static int lpc_master_xfer(struct i2c_adapter *i2c_adap,
		    struct i2c_msg *msgs,
		    int num)
{
	struct i2c_algo_lpc_data *adap = i2c_adap->algo_data;
	struct i2c_msg *pmsg;
	int i;
	int ret=0;

	mutex_lock(&lpc_lock);

	if (adap->xfer_begin)
		adap->xfer_begin(&i2c_adap->nr);


	for (i = 0;ret >= 0 && i < num; i++) {
		pmsg = &msgs[i];

		DEBPROTO(lpc_fprintf_debug("lpc_xfer.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n",
		     pmsg->flags & I2C_M_RD ? "read" : "write",
		     pmsg->len, pmsg->addr, i + 1, num);)

		DEBPROTO(lpc_fprintf_debug("lpc_xfer.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n",
			    i, msgs[i].addr, msgs[i].flags, msgs[i].len);)

		if (pmsg->flags & I2C_M_RD) {
			ret = lpc_readbytes(i2c_adap, pmsg);

			if (ret != pmsg->len) {
				DEBPROTO(lpc_fprintf_debug("lpc_xfer.o: fail: "
					    "only read %d bytes.\n",ret));
			} else {
				DEBPROTO(lpc_fprintf_debug("lpc_xfer.o: read %d bytes.\n",ret));
			}
		} else {

			ret = lpc_sendbytes(i2c_adap, pmsg);

			if (ret != pmsg->len) {
				DEBPROTO(lpc_fprintf_debug("lpc_xfer.o: fail: "
					    "only wrote %d bytes.\n",ret));
			} else {
				DEBPROTO(lpc_fprintf_debug("lpc_xfer.o: wrote %d bytes.\n",ret));
			}
		}
	}

	if (adap->xfer_end)
		adap->xfer_end(&i2c_adap->nr);

	mutex_unlock(&lpc_lock);

	DEBPROTO(lpc_fprintf_debug("ret = 0x%x num = 0x%x i = 0x%x.\n",ret,num,i));

	return ret = (ret < 0) ? ret : num;
}


static u32 lpc_func(struct i2c_adapter *adap)
{
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_SMBUS_QUICK;
}

/* exported algorithm data: */
static const struct i2c_algorithm lpc_algo = {
	.master_xfer	= lpc_master_xfer,
	//.smbus_xfer		= lpc_smbus_xfer,
	.functionality	= lpc_func,
};


/**********************************************   End  ********************************************************/






/**********************************************   Start  ********************************************************/
#define DEFAULT_BASE 0x0a00

static int lpc_base= 0x0a00;
static u8 __iomem *lpc_base_iomem;

static int lpc_irq;
static int lpc_clock  = 0x1c;
static int lpc_own    = 0x55;
static int lpc_mmapped;

static unsigned long lpc_base_addr = 0x0a00;
static unsigned int  lpc_io_space_size = 2;

static unsigned long LPC_INDEX_REG;
static unsigned long LPC_DATA_REG;


/* notice : removed static struct i2c_lpc_iic gpi; code -
  this module in real supports only one device, due to missing arguments
  in some functions, called from the algo-lpc module. Sometimes it's
  need to be rewriten - but for now just remove this for simpler reading */

static wait_queue_head_t lpc_wait;
static int lpc_pending;
static spinlock_t lock;
static spinlock_t lpc_slock;

static struct i2c_adapter lpc_iic_ops;

struct cpld_dev_type {
    struct resource *io_resource;
    struct semaphore sem;
    struct cdev cdev;
};

struct cpld_dev_type *cpld_device;


/* ----- local functions ----------------------------------------------	*/

static void lpc_cpld_setbyte(void *data, int ctl, int val)
{
    outb(ctl, LPC_INDEX_REG);
    mb();

    outb(val, LPC_DATA_REG);
    mb();
}

static int lpc_cpld_getbyte(void *data, int ctl)
{
	u8 val = 0;

    outb(ctl, LPC_INDEX_REG);
    mb();

    val = inb(LPC_DATA_REG);
    mb();

    return val;
}

static void lpc_iic_setbyte(void *data, int ctl, int val)
{
    if (!cpld_device)
    {
        return  ;
    }

    if (down_interruptible(&cpld_device->sem))
	{
		return	;
	}


	lpc_cpld_setbyte(data,ctl,val);

	up(&cpld_device->sem);
	DEBPROTO(lpc_fprintf_debug("%s REG[%x] = %x\n",__func__,ctl,val);)
}


static int lpc_iic_getbyte(void *data, int ctl)
{
	u8 val = 0;
    if (!cpld_device)
        return -ENOTTY;

    if (down_interruptible(&cpld_device->sem))
        return -ERESTARTSYS;

	val = lpc_cpld_getbyte(data,ctl);

	up(&cpld_device->sem);
	DEBPROTO(lpc_fprintf_debug("%s REG[%x] = %x\n",__func__,ctl,val);)
    return val;
}

int cig_cpld_read_register(u8 reg_off, u8 *val)
{
    if (!cpld_device)
        return -ENOTTY;

    if (down_interruptible(&cpld_device->sem))
        return -ERESTARTSYS;

    *val = lpc_cpld_getbyte(cpld_device, reg_off);

	up(&cpld_device->sem);

    return 0;
}
EXPORT_SYMBOL(cig_cpld_read_register);

int cig_cpld_write_register(u8 reg_off, u8 val)
{
    if (!cpld_device)
        return -ENOTTY;

    if (down_interruptible(&cpld_device->sem))
        return -ERESTARTSYS;

    lpc_cpld_setbyte(cpld_device, reg_off, val);
	up(&cpld_device->sem);
    return 0;
}
EXPORT_SYMBOL(cig_cpld_write_register);



static int lpc_iic_getown(void *data)
{
	return (lpc_own);
}


static int lpc_iic_getclock(void *data)
{
	return (lpc_clock);
}

static void lpc_iic_waitforpin(void *data)
{
	DEFINE_WAIT(wait);
	int timeout = 2;
	unsigned long flags;

	if (lpc_irq > 0) {
		spin_lock_irqsave(&lock, flags);
		if (lpc_pending == 0) {
			spin_unlock_irqrestore(&lock, flags);
			prepare_to_wait(&lpc_wait, &wait, TASK_INTERRUPTIBLE);
			if (schedule_timeout(timeout*HZ)) {
				spin_lock_irqsave(&lock, flags);
				if (lpc_pending == 1) {
					lpc_pending = 0;
				}
				spin_unlock_irqrestore(&lock, flags);
			}
			finish_wait(&lpc_wait, &wait);
		} else {
			lpc_pending = 0;
			spin_unlock_irqrestore(&lock, flags);
		}
	} else {
		udelay(100);
	}
}


static irqreturn_t lpc_iic_handler(int this_irq, void *dev_id) {
	spin_lock(&lock);
	lpc_pending = 1;
	spin_unlock(&lock);
	wake_up_interruptible(&lpc_wait);
	return IRQ_HANDLED;
}

static int board_id = 0;


static int lpc_iic_select(void *data)
{
	unsigned int chan_id=0;
	chan_id = *(unsigned int *)data;
	chan_id -= 2;
	DEBPROTO(lpc_fprintf_debug("step 1 : selest channel id = %d\n",chan_id);)
	lpc_iic_setbyte(data,I2C_LPC_REG_BUS_SEL,chan_id);

	return 0;
}

static int lpc_iic_deselect(void *data)
{

	unsigned int chan_id=0;
	chan_id = *(unsigned int *)data;
	chan_id -= 2;
	DEBPROTO(lpc_fprintf_debug("step last :deselect channel id = %d\n",chan_id);)

	return 0;
}


/* ------------------------------------------------------------------------
 * Encapsulate the above functions in the correct operations structure.
 * This is only done when more than one hardware adapter is supported.
 */
static struct i2c_algo_lpc_data lpc_iic_data = {
	.setlpc	    = lpc_iic_setbyte,
	.getlpc	    = lpc_iic_getbyte,
	.getown	    = lpc_iic_getown,
	.getclock   = lpc_iic_getclock,
	.waitforpin = lpc_iic_waitforpin,
	.xfer_begin = lpc_iic_select,
	.xfer_end	= lpc_iic_deselect,
};

#include <linux/i2c-algo-bit.h>

static struct i2c_adapter lpc_iic_arr_ops[LPC_I2C_MAX_NCHANS] = {0};

static void dummy_setscl(void *data, int state)
{
	return;
}

static void dummy_setsda(void *data, int state)
{
	return;

}

static int dummy_getscl(void *data)
{
	return 1;

}

static int dummy_getsda(void *data)
{
	return 1;
}


static struct i2c_algo_bit_data dummy_algo_data = {
	.setsda		= dummy_setsda,
	.setscl		= dummy_setscl,
	.getsda		= dummy_getsda,
	.getscl		= dummy_getscl,
	.udelay		= 50,
	.timeout	= HZ,
};


static int dummy_xfer(struct i2c_adapter *i2c_adap,
		    struct i2c_msg *msgs,
		    int num)
{
	return 1;
}

static u32 dummy_func(struct i2c_adapter *adap)
{
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_SMBUS_QUICK;
}


static const struct i2c_algorithm dummy_algo = {
	.master_xfer	= dummy_xfer,
	.functionality	= dummy_func,
};



static struct i2c_adapter i2c_dummy = {
	.owner		= THIS_MODULE,
	.class		= I2C_CLASS_HWMON,
	.algo_data	= &dummy_algo_data,
	.algo		= &dummy_algo,
	.name		= "i2c_dummy",
};


static int lpc_iic_match(struct device *dev, unsigned int id)
{
	/* sanity checks for lpc_mmapped I/O */

	DEB2(printk("lpc_iic_match\n");)


	if (lpc_base < DEFAULT_BASE) {
		dev_err(dev, "incorrect lpc_base address (%#x) specified "
		       "for lpc_mmapped I/O\n", lpc_base);
		return 0;
	}

	if (lpc_base == 0) {
		lpc_base = DEFAULT_BASE;
	}
	return 1;
}

static int lpc_iic_probe(struct device *dev, unsigned int id)
{
	int rval,num;

	lpc_fprintf_init();

	DEB2(printk("lpc_iic_probe\n");)

	mutex_init(&lpc_lock);

	for(num = 0; num < LPC_I2C_MAX_NCHANS;num++)
	{
		lpc_iic_arr_ops[num].dev.parent = dev;
		lpc_iic_arr_ops[num].owner = THIS_MODULE;
		lpc_iic_arr_ops[num].class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
		lpc_iic_arr_ops[num].algo = &lpc_algo;
		lpc_iic_arr_ops[num].algo_data = &lpc_iic_data,
		lpc_iic_arr_ops[num].nr=num;
		snprintf(lpc_iic_arr_ops[num].name, sizeof(lpc_iic_arr_ops[num].name), "i2c-%d-lpc", i2c_adapter_id(&lpc_iic_arr_ops[num]));
		rval |= i2c_add_adapter(&lpc_iic_arr_ops[num]);
		DEB2(printk("%s\n",lpc_iic_arr_ops[num].name);)
	}

	return 0;
}

static int lpc_iic_remove(struct device *dev, unsigned int id)
{
	int num;
	DEB2(printk("lpc_iic_remove\n"));

	lpc_fprintf_exit();
	for(num = LPC_I2C_MAX_NCHANS - 1; num >= 0 ;num--)
		i2c_del_adapter(&lpc_iic_arr_ops[num]);


	return 0;
}

static struct isa_driver i2c_lpc_driver = {
	.match		= lpc_iic_match,
	.probe		= lpc_iic_probe,
	.remove		= lpc_iic_remove,
	.driver = {
		.owner	= THIS_MODULE,
		.name	= "lpc-iic",
	},
};

/**********************************************   End  ********************************************************/






/**********************************************   Start  ********************************************************/

static int cpld_major = 0;
static int cpld_minor = 0;

struct cpld_rw_msg {
    unsigned char addr;
    unsigned char data;
};


static struct cpld_rw_msg param_read = {-1};
static struct cpld_rw_msg param_write = {-1};
static struct cpld_rw_msg param_reads = {-1};
static struct cpld_rw_msg param_writes = {-1};

void cpld_sysfs_kobj_release(struct kobject *kobj)
{
    return;
}

int cpld_sysfs_add_attr(struct kobject* kobj, char* attr_name)
{

	struct attribute *attr;

    attr = kmalloc(sizeof(struct attribute), GFP_KERNEL);
    attr->name = attr_name;
    attr->mode = 0644;

    return sysfs_create_file(kobj, attr);
}

static int cig_cpld_write_slave_cpld_register(u8 reg_addr, u8 reg_data);
static int cig_cpld_read_slave_cpld_register(u8 reg_addr, u8 *reg_data);


static ssize_t cpld_sysfs_show(struct kobject *kobj, struct attribute *attr, char *buffer)
{
	u8 val=0,ret=0,year=0,month=0,day=0,cpld_m=0,cpld_1=0,cpld_2=0;

    if (0 == strcmp(attr->name, "read"))
    {
		val = lpc_iic_getbyte(NULL,param_read.addr);
		ret = sprintf(buffer,"read : addr = 0x%x val = 0x%x\n",param_read.addr, val);

    }
    else if (0 == strcmp(attr->name, "write"))
    {
		lpc_iic_setbyte(NULL, param_write.addr,param_write.data);
		ret = sprintf(buffer,"write : addr = 0x%x val = 0x%x\n",param_write.addr, param_write.data);
    }
	else if (0 == strcmp(attr->name, "version"))
    {
		cpld_m = lpc_iic_getbyte(NULL, 0x02);
		year = lpc_iic_getbyte(NULL, 0x03);
		month = lpc_iic_getbyte(NULL, 0x04);
		day = lpc_iic_getbyte(NULL, 0x05);

		cig_cpld_read_slave_cpld_register(0x1d,&cpld_1);
		cig_cpld_read_slave_cpld_register(0x1e,&cpld_2);

		ret = sprintf(buffer,"Main CPLD version : V%02x\n"\
							  "Main CPLD date : 20%02x-%02x-%02x\n"\
							  "Slave 1 CPLD version : V%02x\n"\
							  "Slave 2 CPLD version : V%02x\n",cpld_m,year,month,day,cpld_1,cpld_2);
    }
    if (0 == strcmp(attr->name, "reads"))
    {
		ret = cig_cpld_read_slave_cpld_register(param_reads.addr,&val);
		if (ret < 0)
		    printk("ERROR:Failed to read slave cpld.\n");
		ret = sprintf(buffer,"reads : addr = 0x%x val = 0x%x\n",param_reads.addr, val);

    }
    else if (0 == strcmp(attr->name, "writes"))
    {
		ret = cig_cpld_write_slave_cpld_register(param_writes.addr,param_writes.data);
		if (ret < 0)
		    printk("ERROR:Failed to read slave cpld.\n");
		ret = sprintf(buffer,"writes : addr = 0x%x val = 0x%x\n",param_writes.addr, param_writes.data);
    }


    return ret;

}

static ssize_t cpld_sysfs_store(struct kobject *kobj, struct attribute *attr, const char *buffer, size_t count)
{
    int param[3];

    if (0 == strcmp(attr->name, "read"))
    {
        sscanf(buffer, "0x%02x", &param[0]);
        param_read.addr = param[0];
    }
    else if (0 == strcmp(attr->name, "write"))
    {
        sscanf(buffer, "0x%2x 0x%02x", &param[0], &param[1]);
        param_write.addr = param[0];
        param_write.data = param[1];
    }
    if (0 == strcmp(attr->name, "reads"))
    {
        sscanf(buffer, "0x%02x", &param[0]);
        param_reads.addr = param[0];
    }
    else if (0 == strcmp(attr->name, "writes"))
    {
        sscanf(buffer, "0x%2x 0x%02x", &param[0], &param[1]);
        param_writes.addr = param[0];
        param_writes.data = param[1];
    }
	return count;
}



static struct sysfs_ops cpld_sysfs_ops =
{
    .show   = cpld_sysfs_show,
    .store  = cpld_sysfs_store,
};

static struct kobj_type cpld_kobj_type =
{
    .release        = cpld_sysfs_kobj_release,
    .sysfs_ops      = &cpld_sysfs_ops,
    .default_attrs  = NULL,
};


static const char driver_name[] = "cpld_drv";
static atomic_t cpld_available = ATOMIC_INIT(1);
static struct class *cpld_class;
static struct device *cpld_dev;



#define CPLD_IOC_MAGIC  '['

#define CPLD_IOC_RDREG  _IOR(CPLD_IOC_MAGIC, 0, struct cpld_rw_msg)
#define CPLD_IOC_WRREG  _IOW(CPLD_IOC_MAGIC, 1, struct cpld_rw_msg)

#define CPLD_IOC_MAXNR  2


int cpld_open(struct inode *inode, struct file *filp)
{
    struct cpld_dev_type *dev;

    if (! atomic_dec_and_test(&cpld_available)) {
        atomic_inc(&cpld_available);
        return -EBUSY;
    }

    dev = container_of(inode->i_cdev, struct cpld_dev_type, cdev);
    filp->private_data = dev;

    return 0;
}

int cpld_release(struct inode *inode, struct file *flip)
{
    atomic_inc(&cpld_available);
    return 0;
}


long cpld_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int rc = 0;
	int err = 0;
    struct cpld_dev_type *dev = (struct cpld_dev_type *)filp->private_data;
    struct cpld_rw_msg msg;

    if (_IOC_TYPE(cmd) != CPLD_IOC_MAGIC)
        return -ENOTTY;
    if (_IOC_NR(cmd) > CPLD_IOC_MAXNR)
        return -ENOTTY;

    if (_IOC_DIR(cmd) & _IOC_READ)
        err = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));
    if (_IOC_DIR(cmd) & _IOC_WRITE)
        err = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));
    if (err)
        return -EFAULT;

    if (down_interruptible(&dev->sem))
        return -ERESTARTSYS;

    switch(cmd){
        case CPLD_IOC_RDREG:
            rc = copy_from_user(&msg, (void __user *)arg, sizeof(msg));
            if (!rc) {
                msg.data = lpc_cpld_getbyte(dev, msg.addr);
                rc = copy_to_user((void __user *)arg, &msg, sizeof(msg));
            }
            break;

        case CPLD_IOC_WRREG:
            rc = copy_from_user(&msg, (void __user *)arg, sizeof(msg));
            if (!rc) {
                lpc_cpld_setbyte(dev, msg.addr, msg.data);
            }
            break;
        default:
            rc = -ENOTTY;
            break;
    }
    up(&dev->sem);

    return rc;
}

struct file_operations cpld_fops = {
    .owner          = THIS_MODULE,
    .open           = cpld_open,
    .unlocked_ioctl = cpld_ioctl,
    .release        = cpld_release,
};


static void cpld_setup_cdev(struct cpld_dev_type *dev)
{
    int err, devno = MKDEV(cpld_major, cpld_minor);

    cdev_init(&dev->cdev, &cpld_fops);
    dev->cdev.owner = THIS_MODULE;
    dev->cdev.ops = &cpld_fops;
    err = cdev_add(&dev->cdev, devno, 1);

    if (err)
        DEB2(printk(KERN_NOTICE "Error %d adding cpld", err);)
}
/**********************************************    End   ********************************************************/




/**********************************************   Start  ********************************************************/
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/irq.h>

static spinlock_t		irq_inter_lock;
static struct delayed_work irq_inter_work;
static unsigned long irq_inter_delay;


static int cig_cpld_write_slave_cpld_register(u8 reg_addr, u8 reg_data)
{
	u8 read_status = 0;
	u8 wait_time_out = WAIT_TIME_OUT_COUNT;
	DEB2(printk("<=======write=========>"));
	cig_cpld_write_register(ADDR_REG_SFP_STATUS_ADDR, reg_addr << 1);
	DEB2(printk("[62]=%x\n",reg_addr << 1));
	cig_cpld_write_register(ADDR_REG_SFP_STATUS_TX, reg_data);
	DEB2(printk("[63]=%x\n",reg_data));
	cig_cpld_write_register(ADDR_REG_SFP_STATUS_COMMAND, 0x80);
	DEB2(printk("[65]=%x\n",0x80));
	do{
		cig_cpld_read_register(ADDR_REG_SFP_STATUS_STATUS, &read_status);
		DEB2(printk("[66]=%x\n",read_status));
		udelay(60);
		wait_time_out--;
		if(wait_time_out == 0)
			break;
	}while(read_status != 0x02);
	DEB2(printk("<=======write=========>"));


	if(wait_time_out == 0)
		return -1;

	return 1;
}


static int cig_cpld_read_slave_cpld_register(u8 reg_addr, u8 *reg_data)
{
	u8 read_status = 0;
	u8 wait_time_out = WAIT_TIME_OUT_COUNT;
	DEB2(printk("<========read=========>"));
	cig_cpld_write_register(ADDR_REG_SFP_STATUS_ADDR, reg_addr << 1 | 1);
	DEB2(printk("[62]=%x\n",reg_addr << 1 | 1));
	cig_cpld_write_register(ADDR_REG_SFP_STATUS_COMMAND, 0x80);
	DEB2(printk("[65]=%x\n",0x80));
	do{
		udelay(60);
		cig_cpld_read_register(ADDR_REG_SFP_STATUS_STATUS, &read_status);
		DEB2(printk("[66]=%x\n",read_status));
		wait_time_out--;
		if(wait_time_out == 0)
			break;
	}while(read_status != 0x01);

	cig_cpld_read_register(ADDR_REG_SFP_STATUS_RX,reg_data);
	DEB2(printk("[64]=%x\n",*reg_data));
	DEB2(printk("<========read=========>"));

	if(wait_time_out == 0)
		return -1;

	return 1;
}



struct sock *nlsk = NULL;
extern struct net init_net;
#define NETLINK_TEST     26
#define MSG_LEN            125
#define USER_PORT        100
static u32 irq_present_status_low_current,irq_present_status_low_next;
static u32 irq_present_status_high_current,irq_present_status_high_next;
static u32 irq_tx_fault_status_low_current,irq_tx_fault_status_low_next;
static u32 irq_tx_fault_status_high_current,irq_tx_fault_status_high_next;
static u32 irq_rx_lost_status_low_current,irq_rx_lost_status_low_next;
static u32 irq_rx_lost_status_high_current,irq_rx_lost_status_high_next;

static u8 irq_present_qsfp_current,irq_present_qsfp_next;
static u8 irq_interrupt_qsfp_current,irq_interrupt_qsfp_next;

struct input_dev *cpld_input_dev;



int send_usrmsg(char *pbuf, uint16_t len)
{
    struct sk_buff *nl_skb;
    struct nlmsghdr *nlh;

    int ret;


    nl_skb = nlmsg_new(len, GFP_ATOMIC);
    if(!nl_skb)
    {
        printk("netlink alloc failure\n");
        return -1;
    }


    nlh = nlmsg_put(nl_skb, 0, 0, NETLINK_TEST, len, 0);
    if(nlh == NULL)
    {
        printk("nlmsg_put failaure \n");
        nlmsg_free(nl_skb);
        return -1;
    }

    memcpy(nlmsg_data(nlh), pbuf, len);
    ret = netlink_unicast(nlsk, nl_skb, USER_PORT, MSG_DONTWAIT);

    return ret;
}

static void netlink_rcv_msg(struct sk_buff *skb)
{

    struct nlmsghdr *nlh = NULL;
    char *umsg = NULL;
    char kmsg[1024] = {0};
	char kmsg_tmp[16] = {0};
	u8 i = 0;
	u8 tmp[3]={0};

    if(skb->len >= nlmsg_total_size(0))
    {
        nlh = nlmsg_hdr(skb);
        umsg = NLMSG_DATA(nlh);
        if(umsg)
		{
			for(i = 0;i < 24;i++)
			{
				if(!(irq_present_status_low_current & (0x1 << i)))
				{
					tmp[0] = 1;
				}
				else
				{
					tmp[0] = 0;
				}

				if(!(irq_rx_lost_status_low_current & (0x1 << i)))
				{
					tmp[1] = 1;
				}
				else
				{
					tmp[1] = 0;
				}

				if(!(irq_tx_fault_status_low_current & (0x1 << i)))
				{
					tmp[2] = 1;
				}
				else
				{
					tmp[2] = 0;
				}
				memset(kmsg_tmp,0xff,sizeof(kmsg_tmp));
				sprintf(kmsg_tmp,"sfp%02d:%1d:%1d:%1d ",i+1,tmp[0],tmp[1],tmp[2]);
				strcat(kmsg,kmsg_tmp);
			}

			for(i = 0;i < 24;i++)
			{
				if(!(irq_present_status_high_current & (0x1 << i)))
				{
					tmp[0] = 1;
				}
				else
				{
					tmp[0] = 0;
				}

				if(!(irq_rx_lost_status_high_current & (0x1 << i)))
				{
					tmp[1] = 1;
				}
				else
				{
					tmp[1] = 0;
				}

				if(!(irq_tx_fault_status_high_current & (0x1 << i)))
				{
					tmp[2] = 1;
				}
				else
				{
					tmp[2] = 0;
				}
				memset(kmsg_tmp,0xff,sizeof(kmsg_tmp));
				sprintf(kmsg_tmp,"sfp%02d:%1d:%1d:%1d ",i+25,tmp[0],tmp[1],tmp[2]);
				strcat(kmsg,kmsg_tmp);
			}


			for(i = 0;i < 8;i++)
			{
				if(!(irq_present_qsfp_current & (0x1 << i)))
				{
					tmp[0] = 1;
				}
				else
				{
					tmp[0] = 0;
				}

				if(!(irq_interrupt_qsfp_current & (0x1 << i)))
				{
					tmp[1] = 1;
				}
				else
				{
					tmp[1] = 0;
				}

				memset(kmsg_tmp,0xff,sizeof(kmsg_tmp));
				sprintf(kmsg_tmp,"qsfp%02d:%1d:%1d:%1d ",i+49,tmp[0],tmp[1],0);
				strcat(kmsg,kmsg_tmp);
			}

            printk("kernel recv from user: %s\n", umsg);
            send_usrmsg(kmsg, strlen(kmsg));
        }
    }

	return ;
}



struct netlink_kernel_cfg cfg = {
        .input  = netlink_rcv_msg, /* set recv callback */
};



#define RANGE_OF_BYTE_SHIFT(to_arg,shift,from_arg)  {to_arg &= ~(0xff << shift); to_arg |= from_arg << shift;}


static void irq_inter_wapper(struct work_struct * work)
{

	u8 m_data = 0;
	u8 data_high8 = 0,data_low8 = 0;
	u16 data_16 = 0;
	u8 status = 0;
	u8 i = 0;
	char kmsg[64]={0};
	u8 tmp[3] = {0};

	DEB2(printk("CPLD_MASTER_INTERRUPT\r\n"));

	m_data = lpc_iic_getbyte(NULL,CPLD_MASTER_INTERRUPT_STATUS_REG);
	lpc_iic_setbyte(NULL,CPLD_MASTER_INTERRUPT_STATUS_REG,0xff);

	cig_cpld_write_slave_cpld_register(CPLD_SLAVE1_INTERRUPT_MASK_REG,0xff);
	cig_cpld_write_slave_cpld_register(CPLD_SLAVE2_INTERRUPT_MASK_REG,0xff);
	if(!(m_data & CPLD_MASTER_INTERRUPT_CPLD1))
	{
		cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_INTERRUPT_STATUS_H_REG,&data_high8);
		cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_INTERRUPT_STATUS_L_REG,&data_low8);
		data_16 = data_low8 | data_high8 << 8;
		if(
			!(data_16 & CPLD_SLAVE1_INTERRUPT_PRESENT08) ||
			!(data_16 & CPLD_SLAVE1_INTERRUPT_PRESENT16) ||
			!(data_16 & CPLD_SLAVE1_INTERRUPT_PRESENT24)
		)
		{
			if(!(data_16 & CPLD_SLAVE1_INTERRUPT_PRESENT08))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_PRESENT08\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_PRESENT08_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_present_status_low_current,0,status);

			}
			else if(!(data_16 & CPLD_SLAVE1_INTERRUPT_PRESENT16))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_PRESENT16\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_PRESENT16_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_present_status_low_current,8,status);
			}
			else if(!(data_16 & CPLD_SLAVE1_INTERRUPT_PRESENT24))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_PRESENT24\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_PRESENT24_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_present_status_low_current,16,status);
			}
			DEB2(printk("irq_present_status_low_next = %08x irq_present_status_low_current = %08x \n",irq_present_status_low_next,irq_present_status_low_current));
		}

		if(
			!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST08) ||
			!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST16) ||
			!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST24)
		)
		{
			if(!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST08))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_RX_LOST08\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_RX_LOST08_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_rx_lost_status_low_current,0,status);

			}
			else if(!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST16))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_PRESENT16\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_RX_LOST16_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_rx_lost_status_low_current,8,status);
			}
			else if(!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST24))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_PRESENT24\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_RX_LOST24_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_rx_lost_status_low_current,16,status);
			}
			DEB2(printk("irq_rx_lost_status_low_next = %08x irq_rx_lost_status_low_current = %08x \n",irq_rx_lost_status_low_next,irq_rx_lost_status_low_current));
		}

		if(
			!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST08) ||
			!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST16) ||
			!(data_16 & CPLD_SLAVE1_INTERRUPT_RX_LOST24)
		)
		{
			if(!(data_16 & CPLD_SLAVE1_INTERRUPT_TX_FAULT08))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_TX_FAULT08\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_TX_FAULT08_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_tx_fault_status_low_current,0,status);

			}
			else if(!(data_16 & CPLD_SLAVE1_INTERRUPT_TX_FAULT16))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_TX_FAULT16\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_TX_FAULT16_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_tx_fault_status_low_current,8,status);
			}
			else if(!(data_16 & CPLD_SLAVE1_INTERRUPT_TX_FAULT24))
			{
				DEB2(printk("CPLD_SLAVE1_INTERRUPT_TX_FAULT24\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE1_TX_FAULT24_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_tx_fault_status_low_current,16,status);
			}
			DEB2(printk("irq_tx_fault_status_low_next = %08x irq_tx_fault_status_low_current = %08x \n",irq_tx_fault_status_low_next,irq_tx_fault_status_low_current));

		}
	}
	else if(!(m_data & CPLD_MASTER_INTERRUPT_CPLD2))
	{
		cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_INTERRUPT_STATUS_H_REG,&data_high8);
		cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_INTERRUPT_STATUS_L_REG,&data_low8);
		data_16 = data_low8 | data_high8 << 8;
		if(
			!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT32) ||
			!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT40) ||
			!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT48)
		)
		{
			if(!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT32))
			{
				DEB2(printk("CPLD_SLAVE2_PRESENT32_REG\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_PRESENT32_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_present_status_high_current,0,status);
			}
			else if(!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT40))
			{
				DEB2(printk("CPLD_SLAVE2_PRESENT40_REG\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_PRESENT40_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_present_status_high_current,8,status);
			}
			else if(!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT48))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_PRESENT48\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_PRESENT48_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_present_status_high_current,16,status);
			}
		}

		if(
			!(data_16 & CPLD_SLAVE2_INTERRUPT_RX_LOST32) ||
			!(data_16 & CPLD_SLAVE2_INTERRUPT_RX_LOST40) ||
			!(data_16 & CPLD_SLAVE2_INTERRUPT_RX_LOST48)
		)
		{
			if(!(data_16 & CPLD_SLAVE2_INTERRUPT_RX_LOST32))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_RX_LOST32\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_RX_LOST32_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_rx_lost_status_high_current,0,status);
			}
			else if(!(data_16 & CPLD_SLAVE2_INTERRUPT_RX_LOST40))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_PRESENT40\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_RX_LOST40_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_rx_lost_status_high_current,8,status);
			}
			else if(!(data_16 & CPLD_SLAVE2_INTERRUPT_RX_LOST48))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_PRESENT48\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_RX_LOST48_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_rx_lost_status_high_current,16,status);
			}

		}

		if(
			!(data_16 & CPLD_SLAVE2_INTERRUPT_TX_FAULT32) ||
			!(data_16 & CPLD_SLAVE2_INTERRUPT_TX_FAULT40) ||
			!(data_16 & CPLD_SLAVE2_INTERRUPT_TX_FAULT48)
		)
		{
			if(!(data_16 & CPLD_SLAVE2_INTERRUPT_TX_FAULT32))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_RX_LOST32\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_TX_FAULT32_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_tx_fault_status_high_current,0,status);
			}
			else if(!(data_16 & CPLD_SLAVE2_INTERRUPT_TX_FAULT40))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_PRESENT40\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_TX_FAULT40_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_tx_fault_status_high_current,8,status);
			}
			else if(!(data_16 & CPLD_SLAVE2_INTERRUPT_TX_FAULT48))
			{
				DEB2(printk("CPLD_SLAVE2_INTERRUPT_PRESENT48\r\n"));
				cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_TX_FAULT48_REG,&status);
				RANGE_OF_BYTE_SHIFT(irq_tx_fault_status_high_current,16,status);
			}
		}

		if(!(data_16 & CPLD_SLAVE2_INTERRUPT_PRESENT56))
		{
			DEB2(printk("CPLD_SLAVE2_PRESENT56_REG\r\n"));
			cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_PRESENT56_REG,&status);
			irq_present_qsfp_current = status;
		}

		if(!(data_16 & CPLD_SLAVE2_INTERRUPT_QSFP_CR56))
		{
			DEB2(printk("CPLD_SLAVE2_QSFP_CR56_REG\r\n"));
			cig_cpld_read_slave_cpld_register(CPLD_SLAVE2_QSFP_CR56_REG,&status);
			irq_interrupt_qsfp_current = status;
		}
	}
	else if(!(m_data & CPLD_MASTER_INTERRUPT_LSW))
	{
		DEB2(printk("CPLD_MASTER_INTERRUPT_LSW\r\n"));
	}
	else if(!(m_data & CPLD_MASTER_INTERRUPT_PSU1))
	{
		DEB2(printk("CPLD_MASTER_INTERRUPT_PSU1\r\n"));
	}
	else if(!(m_data & CPLD_MASTER_INTERRUPT_PSU2))
	{
		DEB2(printk("CPLD_MASTER_INTERRUPT_PSU2\r\n"));
	}
	else if(!(m_data & CPLD_MASTER_INTERRUPT_6320))
	{
		DEB2(printk("CPLD_MASTER_INTERRUPT_6320\r\n"));
	}
	cig_cpld_write_slave_cpld_register(CPLD_SLAVE1_INTERRUPT_MASK_REG,0x0);
	cig_cpld_write_slave_cpld_register(CPLD_SLAVE2_INTERRUPT_MASK_REG,0x0);

	memset(tmp,0xff,sizeof(tmp));

	for(i = 0;i < 24;i++)
	{
		if(!(irq_present_status_low_current & (0x1 << i)) && (irq_present_status_low_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d is present\r\n",i+1));
			tmp[0] = 1;
		}
		else if((irq_present_status_low_current & (0x1 << i)) && !(irq_present_status_low_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d is absent\r\n",i+1));
			tmp[0] = 0;
		}

		if(!(irq_tx_fault_status_low_current & (0x1 << i)) && (irq_tx_fault_status_low_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d transmission is right\r\n",i+1));
			tmp[1] = 1;
		}
		else if((irq_tx_fault_status_low_current & (0x1 << i)) && !(irq_tx_fault_status_low_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d transmission is fault\r\n",i+1));
			tmp[1] = 0;
		}

		if(!(irq_rx_lost_status_low_current & (0x1 << i)) && (irq_rx_lost_status_low_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d optical is meet\r\n",i+1));
			tmp[2] = 1;
		}
		else if((irq_rx_lost_status_low_current & (0x1 << i)) && !(irq_rx_lost_status_low_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d optical is lost\r\n",i+1));
			tmp[2] = 0;
		}

		if((tmp[0] != 0xff) || (tmp[1] != 0xff) || (tmp[2] != 0xff))
		{
			memset(kmsg,0xff,sizeof(kmsg));
			snprintf(kmsg,sizeof(kmsg),"sfp%02d:%1d:%1d:%1d ",i+1,(tmp[0] == 0xff) ? 0:tmp[0],(tmp[1] == 0xff) ? 0:tmp[1],(tmp[2] == 0xff) ? 0:tmp[2]);
			break;
		}
	}

	memset(tmp,0xff,sizeof(tmp));
	for(i = 0;i < 24;i++)
	{
		if(!(irq_present_status_high_current & (0x1 << i)) && (irq_present_status_high_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d is present\r\n",i+25));
			tmp[0] = 1;
		}
		else if((irq_present_status_high_current & (0x1 << i)) && !(irq_present_status_high_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d is absent\r\n",i+25));
			tmp[0] = 0;

		}

		if(!(irq_rx_lost_status_high_current & (0x1 << i)) && (irq_rx_lost_status_high_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d optical is meet\r\n",i+25));
			tmp[1] = 1;
		}
		else if((irq_rx_lost_status_high_current & (0x1 << i)) && !(irq_rx_lost_status_high_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d optical is lost\r\n",i+25));
			tmp[1] = 0;
		}

		if(!(irq_tx_fault_status_high_current & (0x1 << i)) && (irq_tx_fault_status_high_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d transmission is right\r\n",i+25));
			tmp[2] = 1;
		}
		else if((irq_tx_fault_status_high_current & (0x1 << i)) && !(irq_tx_fault_status_high_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d transmission is fault\r\n",i+25));
			tmp[2] = 0;
		}

		if((tmp[0] != 0xff) || (tmp[1] != 0xff) || (tmp[2] != 0xff))
		{
			memset(kmsg,0xff,sizeof(kmsg));
			snprintf(kmsg,sizeof(kmsg),"sfp%02d:%1d:%1d:%1d ",i+25,(tmp[0] == 0xff) ? 0:tmp[0],(tmp[1] == 0xff) ? 0:tmp[1],(tmp[2] == 0xff) ? 0:tmp[2]);
			break;
		}
	}

	memset(tmp,0xff,sizeof(tmp));
	for(i = 0 ; i < 8; i++)
	{
		if(!(irq_present_qsfp_current & (0x1 << i)) && (irq_present_qsfp_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d is present\r\n",i+49));
			tmp[0] = 1;
		}
		else if((irq_present_qsfp_current & (0x1 << i)) && !(irq_present_qsfp_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d is absent\r\n",i+49));
			tmp[0] = 0;
		}

		if(!(irq_interrupt_qsfp_current & (0x1 << i)) && (irq_interrupt_qsfp_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d interrupt is occured \r\n",i+49));
			tmp[1] = 1;
		}
		else if((irq_interrupt_qsfp_current & (0x1 << i)) && !(irq_interrupt_qsfp_next & (0x1 << i)))
		{
			DEB2(printk("SFP%d interrupt is cleaned\r\n",i+49));
			tmp[1] = 0;
		}

		if((tmp[0] != 0xff) || (tmp[1] != 0xff))
		{
			memset(kmsg,0xff,sizeof(kmsg));
			snprintf(kmsg,sizeof(kmsg),"qsfp%02d:%1d:%1d:%1d ",i+49,(tmp[0] == 0xff) ? 0:tmp[0],(tmp[1] == 0xff) ? 0:tmp[1],0);
			break;
		}
	}


	irq_present_status_low_next = irq_present_status_low_current;
	irq_rx_lost_status_low_next = irq_rx_lost_status_low_current;
	irq_tx_fault_status_low_next = irq_tx_fault_status_low_current;
	irq_present_status_high_next = irq_present_status_high_current;
	irq_rx_lost_status_high_next = irq_rx_lost_status_high_current;
	irq_tx_fault_status_high_next = irq_tx_fault_status_high_current;
	irq_present_qsfp_next =  irq_present_qsfp_current;
	irq_interrupt_qsfp_next = irq_interrupt_qsfp_current;

    send_usrmsg(kmsg, strlen(kmsg));
}

static void disableIrq(unsigned short maskReg, unsigned short mask)
{
    u8 data = 0;

    data = lpc_iic_getbyte(NULL,maskReg);
    data |= mask;
    lpc_iic_setbyte(NULL,maskReg, data);
}

static void enableIrq(unsigned short maskReg, unsigned short mask)
{
    unsigned short data;

    data = lpc_iic_getbyte(NULL,maskReg);
    data &= ~mask;
    lpc_iic_setbyte(NULL,maskReg, data);
}


static irqreturn_t irq_inter_isr(int irq, void *handle)
{

	/*
	 * use keventd context to read the event fifo registers
	 * Schedule readout at least 25ms after notification for
	 * REVID < 4
	 */

	schedule_delayed_work(&irq_inter_work, irq_inter_delay);

	return IRQ_HANDLED;
}


#define CIG_CPLD_CHR_NAME "cpld"


static int __init cpld_init(void)
{
	int rval,rc=0;
	dev_t dev;
	u8 s_data;

	DEB2(printk("cpld_init\n");)

/**************************************************************************************/

	LPC_INDEX_REG = lpc_base_addr;
    LPC_DATA_REG  = lpc_base_addr + 1;

    cpld_device = kzalloc(sizeof(struct cpld_dev_type), GFP_KERNEL);
    if (!cpld_device)
        goto error3;
    cpld_device->io_resource = request_region(lpc_base_addr,
                                            lpc_io_space_size, "lpc-i2c");
    if (!cpld_device->io_resource) {
        printk("lpc: claim I/O resource fail\n");
        goto error2;
    }
    sema_init(&cpld_device->sem, 1);

    if (cpld_major) {
        dev = MKDEV(cpld_major, cpld_minor);
        rc = register_chrdev_region(dev, 1, CIG_CPLD_CHR_NAME);
    } else {
        rc = alloc_chrdev_region(&dev, cpld_major, 1, CIG_CPLD_CHR_NAME);
        cpld_major = MAJOR(dev);
    }

    cpld_setup_cdev(cpld_device);

    cpld_class = class_create(THIS_MODULE,CIG_CPLD_CHR_NAME);
    if (!cpld_class) {
        DEB2(printk("failed to create class\n");)
        goto error1;
    }

	cpld_class->p->subsys.kobj.ktype= &cpld_kobj_type;
	cpld_sysfs_add_attr(&cpld_class->p->subsys.kobj, "read");
	cpld_sysfs_add_attr(&cpld_class->p->subsys.kobj, "write");
	cpld_sysfs_add_attr(&cpld_class->p->subsys.kobj, "reads");
	cpld_sysfs_add_attr(&cpld_class->p->subsys.kobj, "writes");
	cpld_sysfs_add_attr(&cpld_class->p->subsys.kobj, "version");

    cpld_dev = device_create(cpld_class, NULL, dev, NULL, CIG_CPLD_CHR_NAME);

/**************************************************************************************/

	rval = lpc_bus_init();
	rval = lpc_register_driver(&i2c_lpc_driver, 1);

/**************************************************************************************/
	return 0;
error1:
    cdev_del(&cpld_device->cdev);
    unregister_chrdev_region(dev, 1);
error2:
    release_resource(cpld_device->io_resource);
error3:
    kfree(cpld_device);

	return rc;
}

static void __exit cpld_exit(void)
{
    DEB2(printk("cpld_exit\n"));

    lpc_unregister_driver(&i2c_lpc_driver);
    lpc_bus_exit();
    dev_t devno = MKDEV(cpld_major, cpld_minor);

    cdev_del(&cpld_device->cdev);
    if (cpld_class) {
        device_destroy(cpld_class, devno);
        class_destroy(cpld_class);
    }

    if (cpld_device) {
        if (cpld_device->io_resource)
            release_resource(cpld_device->io_resource);

        kfree(cpld_device);
    }
	unregister_chrdev_region(devno, 1);


}

module_param(cpld_major, int, S_IRUGO);
module_param(cpld_minor, int, S_IRUGO);
module_param(i2c_debug, int, S_IRUGO);
module_param(board_id, int, S_IRUGO);

module_init(cpld_init);
module_exit(cpld_exit);

MODULE_AUTHOR("Zhang Peng <zhangpeng@cigtech.com>");
MODULE_DESCRIPTION("cs6436-54p-cpld driver");
MODULE_LICENSE("GPL");


/**********************************************   End  ********************************************************/