/* drivers/rtc/rtc-jwwdt.c - driver for jwwdt
 *
 * Copyright (C) 2010 ROCKCHIP, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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.
 */


#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/i2c.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/of_gpio.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/tlv.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/initval.h>
#include <linux/proc_fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include "jw_mcu.h"
#include <linux/reboot.h>


struct i2c_client *gClient = NULL;
struct device_node *node_MCU = NULL;
struct device *dev_MCU= NULL;
unsigned int mcu_watchdog_gpio;
struct delayed_work 	    watchdog_delay_work;
#define	WATCHDOG_FEED_COUNT		 2000



//ison s
#if 0
static int Mcu_i2c_writes(const struct i2c_client *client,
		const char reg, const char *buf, int count)
{
        struct i2c_adapter *adap=client->adapter;
        struct i2c_msg msg;
        int ret;
        char *tx_buf = (char *)kmalloc(count + 1, GFP_KERNEL);
        if(!tx_buf)
                return -ENOMEM;
        tx_buf[0] = reg;
        memcpy(tx_buf+1, buf, count);

        msg.addr = client->addr;
        msg.flags = client->flags;
        msg.len = count + 1;
        msg.buf = (char *)tx_buf;
        //msg.scl_rate = 100*1000;

        ret = i2c_transfer(adap, &msg, 1);
        kfree(tx_buf);
        return (ret == 1) ? count : ret;

}

static int Mcu_i2c_reads(const struct i2c_client *client,
		const char reg, char *buf, int count)
{
        struct i2c_adapter *adap=client->adapter;
        struct i2c_msg msgs[2];
        int ret;
        char reg_buf = reg;

        msgs[0].addr = client->addr;
        msgs[0].flags = client->flags;
        msgs[0].len = 1;
        msgs[0].buf = &reg_buf;
        //msgs[0].scl_rate = 100*1000;

        msgs[1].addr = client->addr;
        msgs[1].flags = client->flags | I2C_M_RD;
        msgs[1].len = count;
        msgs[1].buf = (char *)buf;
        //msgs[1].scl_rate = 100*1000;

        ret = i2c_transfer(adap, msgs, 2);

        return (ret == 2)? count : ret;
}
#endif

static int Mcu_i2c_writeregister(struct i2c_client *i2c, char reg, int count, const u8 src)
{
	int ret=-1;
	
	struct i2c_adapter *adap;
	struct i2c_msg msg;
	char tx_buf[2];

	if(!i2c)
		return -EINVAL;
	if (count != 1)
		return -EIO;
    
	adap = i2c->adapter;		
	tx_buf[0] = reg;
	tx_buf[1] = src;
	
	msg.addr = i2c->addr;
	msg.buf = &tx_buf[0];
	msg.len = 1 +1;
	msg.flags = i2c->flags;   
	//msg.scl_rate = 100*1000;	

	ret = i2c_transfer(adap, &msg, 1);
	return ret;	
}



static int Mcu_i2c_readregister(struct i2c_client *i2c, char reg, int count,	u8 *dest)
{
      int ret;
    struct i2c_adapter *adap;
    struct i2c_msg msgs[2];

    if(!i2c)
		return -EINVAL;

	if (count != 1)
		return -EIO;  
  
    adap = i2c->adapter;		
    
    msgs[0].addr = i2c->addr;
    msgs[0].buf = &reg;
    msgs[0].flags = i2c->flags;
    msgs[0].len = 1;
    //msgs[0].scl_rate = 100*1000;
    
    msgs[1].buf = (u8 *)dest;
    msgs[1].addr = i2c->addr;
    msgs[1].flags = i2c->flags | I2C_M_RD;
    msgs[1].len = 1;
    //msgs[1].scl_rate = 100*1000;
    ret = i2c_transfer(adap, msgs, 2);

	//printk("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));

	return ret;   
}

//ison e

uint8_t get_value_func_cfg(uint8_t func, uint8_t value)
{
    uint8_t data = 0;
    CORE_REG_FUNCTION *value_func;
    CORE_REG_FUNCTION1 *value_func1;
    value_func = (CORE_REG_FUNCTION *)&value;
    value_func1 = (CORE_REG_FUNCTION1 *)&value;
    if(func < 100 || func > CORE_FUNC_MAX)
      return 0;
    switch(func){
      case CORE_FUNC_ALARM:
        data = value_func->bit.alarmWakeup;
        break;
      case CORE_FUNC_WDT:
        data = value_func->bit.watchdog;
        break;
      case CORE_FUNC_IRDA:
        data = value_func->bit.irdaWakeup;
        break;
      case CORE_FUNC_NET_WK:
        data = value_func->bit.net_wakeup;
        break;
      case CORE_FUNC_CEC:
        data = value_func->bit.hdmi_cec;
        break;
      case CORE_FUNC_POWER_LOSS:
        data = value_func->bit.powerloss;
        break;
      case CORE_FUNC_USB_CHARGER:
        data = value_func->bit.usbCharger;
        break;   
      case CORE_FUNC_LAST_STATE:
        data = value_func1->bit.last_state;
        break;  
      case CORE_FUNC_PWR_WK_EN:
        data = value_func1->bit.pwr_wk_en;
	  	 case CORE_FUNC_PWR_OFF_EN:
        data = value_func1->bit.pwr_opwer_en;
      default:
        break;       
    }
    return data;
}

uint8_t set_value_func_cfg(uint8_t func, uint8_t value,uint8_t value_data)
{
    uint8_t data = 0;
    CORE_REG_FUNCTION *value_func;
    CORE_REG_FUNCTION1 *value_func1;
    value_func = (CORE_REG_FUNCTION *)&value;
    value_func1 = (CORE_REG_FUNCTION1 *)&value;
    if(func < 100 || func > CORE_FUNC_MAX)
      return 0;
    switch(func){
      case CORE_FUNC_POWER_LOSS:
        value_func->bit.powerloss = value_data;
        break;
      case CORE_FUNC_WDT:
        value_func->bit.watchdog = value_data;
        break;	
      case CORE_FUNC_ALARM:
        value_func->bit.alarmWakeup = value_data;
        break;	
      case CORE_FUNC_PWR_WK_EN:
        value_func1->bit.pwr_wk_en = value_data;
        break;	
	  case CORE_FUNC_PWR_OFF_EN:
        value_func1->bit.pwr_opwer_en = value_data;
        break;	
      default:
        break;       
    }
	data = *((uint8_t *)value_func);
	return data;
}


//add spirit class s------------------------
#if 1

static ssize_t mcu_driver_version(struct class *cls,
					struct class_attribute *attr,
					char *buf)
{
	u8 newversion=0x04;   //if MCU firmware need to update ,set newversion to latest MCU firmware version

	return snprintf(buf, 4, "%02x\n",newversion);
}

static ssize_t spirit_version(struct class *cls,
					struct class_attribute *attr,
					char *buf)
{  
	int ret = 0;
	u8 read_mcu_id = 0; 
	ret = Mcu_i2c_readregister(gClient, CORE_FW_VERSION, 1,&read_mcu_id);
	if (ret < 0) {
		printk("jw_mcu read fail\n");
		return -EINVAL;
	}
	printk("spirit_version  = %d ------------ison\n",read_mcu_id);

	return snprintf(buf, 4, "%02x\n",read_mcu_id);
}

static void MCU_UPDATE(void){
	int ret = 0;
	u8 tmp ;
	
	tmp=1;
	ret = Mcu_i2c_writeregister(gClient, CORE_FW_UPDATE, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(100);
	kernel_restart(NULL);
	printk("CORE_FW_UPDATE ret = %d ------------ison\n",ret);

}

static ssize_t set_mcu_update(struct class *cls, 
						struct class_attribute *attr,
			 			const char *buf, size_t size)
{
	u32 enable;
	sscanf(buf, "%d", &enable);
	printk("Spirit UPDATE enable =%d----ison\n",enable);
	if (enable)
	{
		printk("Spirit UPDATE------ISON\n");
		MCU_UPDATE();
	}
	return size;
}
#endif
static ssize_t get_mcu_state_autopower(struct class *class,struct class_attribute *attr, char *buf)
{
	int ret = 0;
	u8 autopower_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&autopower_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return -1;
		}
		printk("get_autopower autopower_reg = %d ------------ison\n",autopower_state);
	if(get_value_func_cfg(CORE_FUNC_POWER_LOSS,autopower_state)){	
		autopower_state = 1;
	}else{
		autopower_state = 0;
	}
	printk("get_autopower autopower_state = %d ------------ison\n",autopower_state);
	return snprintf(buf, 3, "%02x\n",autopower_state);
}

static void MCU_EnableAutopower(void){
	int ret = 0;
	u8 tmp ;
	u8 autopower_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&autopower_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}
	tmp = set_value_func_cfg(CORE_FUNC_POWER_LOSS,autopower_state,1);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("EnableAutopower ret = %d ------------ison\n",ret);

}

static void MCU_disableAutopower(void){
	int ret = 0;
	u8 tmp ;
	u8 autopower_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&autopower_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}	
	tmp = set_value_func_cfg(CORE_FUNC_POWER_LOSS,autopower_state,0);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("disableAutopower ret = %d ------------ison\n",ret);

}

static ssize_t set_mcu_enable_autopower(struct class *cls, 
						struct class_attribute *attr,
			 			const char *buf, size_t size)
{
	u32 enable;
	sscanf(buf, "%d", &enable);
	printk("set_autopower enable =%d----ison\n",enable);
	if (enable)
	{
		//printk("set_mcu_enable_autopower ENABLE------ISON\n");
		MCU_EnableAutopower();
	}
	else {
		MCU_disableAutopower();
		//printk("set_mcu_enable_autopower DISABLE------ISON\n");
	}
	return size;
}

static ssize_t get_mcu_state_watchdog(struct class *class,struct class_attribute *attr, char *buf)
{
	int ret = 0;
	u8 watchdog_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&watchdog_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return -1;
		}
		printk("get_watchdog watchdog_state = %d ------------ison\n",watchdog_state);
	if(get_value_func_cfg(CORE_FUNC_WDT,watchdog_state)){	
		watchdog_state = 1;
	}else{
		watchdog_state = 0;
	}
	printk("get_watchdog watchdog_state = %d ------------ison\n",watchdog_state);
	return snprintf(buf, 3, "%02x\n",watchdog_state);
}

static void MCU_EnableWatchdog(void){
	int ret = 0;
	u8 tmp ;
	u8 watchdog_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&watchdog_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}
	tmp = set_value_func_cfg(CORE_FUNC_WDT,watchdog_state,1);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("EnableWatchdog ret = %d ------------ison\n",ret);

}

static void MCU_disableWatchdog(void){
	int ret = 0;
	u8 tmp ;
	u8 watchdog_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&watchdog_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}	
	tmp = set_value_func_cfg(CORE_FUNC_WDT,watchdog_state,0);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("disableWatchdog ret = %d ------------ison\n",ret);

}

static void watchdog_work(void){
  int ret;

  ret = gpio_direction_output(mcu_watchdog_gpio, 1); 
  if(ret < 0){
	  printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
  }
  ret = gpio_direction_output(mcu_watchdog_gpio, 0); 
  if(ret < 0){
	  printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
  }
  ret = gpio_direction_output(mcu_watchdog_gpio, 1); 
  if(ret < 0){
	  printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
  }

}

static void watchdog_timer_work(struct work_struct *work)
{
	watchdog_work();
	schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
}


void watchdog_init(void){
	int ret = 0;
	enum of_gpio_flags flags;
	ret = of_get_named_gpio_flags(node_MCU, "mcu_watchdog_gpio", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property mcu_watchdog_gpio\n", __FUNCTION__);
	} else {
		mcu_watchdog_gpio = ret;
		ret = devm_gpio_request(dev_MCU, mcu_watchdog_gpio, "mcu_watchdog_gpio");
		if(ret < 0){
			printk("%s() devm_gpio_request mcu_watchdog_gpio request ERROR\n", __FUNCTION__);
		}
		ret = gpio_direction_output(mcu_watchdog_gpio,1); 
		if(ret < 0){
			printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
		}
	}	

	 INIT_DELAYED_WORK(&watchdog_delay_work, watchdog_timer_work);
     schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
}

static ssize_t set_mcu_enable_watchdog(struct class *cls, 
						struct class_attribute *attr,
			 			const char *buf, size_t size)
{
	u32 enable;
	sscanf(buf, "%d", &enable);
	printk("set_autopower enable =%d----\n",enable);
	if (enable)
	{
		printk("set_mcu_enable_autopower ENABLE------\n");
		MCU_EnableWatchdog();

		
	    schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
		
	}
	else {
		MCU_disableWatchdog();
		schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(0));

		
		printk("set_mcu_enable_autopower DISABLE------\n");
	}
	return size;
}

static ssize_t set_watchdog_test(struct class *cls, 
						struct class_attribute *attr,
			 			const char *buf, size_t size)
{
	u32 enable;
	sscanf(buf, "%d", &enable);
	printk("set_watchdog_test enable =%d----ison\n",enable);
	if (enable)
	{
		//printk("set_mcu_enable_autopower ENABLE------ISON\n");
		schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
	}
	else {
		cancel_delayed_work(&watchdog_delay_work);
		//printk("set_mcu_enable_autopower DISABLE------ISON\n");
	}
	return size;
}

static ssize_t get_mcu_state_rtcpower(struct class *class,struct class_attribute *attr, char *buf)
{
	int ret = 0;
	u8 rtcpower_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&rtcpower_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return -1;
		}
		printk("get_rtcpower rtcpower_state = %d ------------ison\n",rtcpower_state);
	if(get_value_func_cfg(CORE_FUNC_ALARM,rtcpower_state)){	
		rtcpower_state = 1;
	}else{
		rtcpower_state = 0;
	}
	printk("get_rtcpower rtcpower_state = %d ------------ison\n",rtcpower_state);
	return snprintf(buf, 3, "%02x\n",rtcpower_state);
}

static void MCU_EnableRtcpower(void){
	int ret = 0;
	u8 tmp ;
	u8 rtcpower_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&rtcpower_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}
	tmp = set_value_func_cfg(CORE_FUNC_ALARM,rtcpower_state,1);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("EnableRtcpower ret = %d ------------ison\n",ret);

}

static void MCU_disableRtcpower(void){
	int ret = 0;
	u8 tmp ;
	u8 rtcpower_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1,	&rtcpower_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}	
	tmp = set_value_func_cfg(CORE_FUNC_ALARM,rtcpower_state,0);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("disableRtcpower ret = %d ------------ison\n",ret);

}

static ssize_t set_mcu_enable_rtcpower(struct class *cls, 
						struct class_attribute *attr,
			 			const char *buf, size_t size)
{
	u32 enable;
	sscanf(buf, "%d", &enable);
	printk("set_rtcpower enable =%d----ison\n",enable);
	if (enable)
	{
		//printk("set_mcu_enable_autopower ENABLE------ISON\n");
		MCU_EnableRtcpower();
	}
	else {
		MCU_disableRtcpower();
		//printk("set_mcu_enable_autopower DISABLE------ISON\n");
	}
	return size;
}

static ssize_t get_mcu_state_ethwol(struct class *class,struct class_attribute *attr, char *buf)
{
	int ret = 0;
	u8 ethwol_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,	&ethwol_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return -1;
		}
		printk("get_ethwol ethwol_state = %d ------------ison\n",ethwol_state);
	if(get_value_func_cfg(CORE_FUNC_PWR_WK_EN,ethwol_state)){	
		ethwol_state = 1;
	}else{
		ethwol_state = 0;
	}
	printk("get_ethwol ethwol_state = %d ------------ison\n",ethwol_state);
	return snprintf(buf, 3, "%02x\n",ethwol_state);
}

static void MCU_EnableEthwol(void){
	int ret = 0;
	u8 tmp ;
	u8 ethwol_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,	&ethwol_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}
	tmp = set_value_func_cfg(CORE_FUNC_PWR_WK_EN,ethwol_state,1);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("EnableEthwol ret = %d ------------ison\n",ret);

}

static void MCU_disableEthwol(void){
	int ret = 0;
	u8 tmp ;
	u8 ethwol_state=0;
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,	&ethwol_state);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return;
		}	
	tmp = set_value_func_cfg(CORE_FUNC_PWR_WK_EN,ethwol_state,0);
	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return;
	}
	msleep(10);
	printk("disableEthwol ret = %d ------------ison\n",ret);

}

static ssize_t set_mcu_enable_ethwol(struct class *cls, 
						struct class_attribute *attr,
			 			const char *buf, size_t size)
{
	u32 enable;
	sscanf(buf, "%d", &enable);
	printk("set_ethwol enable =%d----ison\n",enable);
	if (enable)
	{
		//printk("set_mcu_enable_autopower ENABLE------ISON\n");
		MCU_EnableEthwol();
	}
	else {
		MCU_disableEthwol();
		//printk("set_mcu_enable_autopower DISABLE------ISON\n");
	}
	return size;
}


static struct class *spirit_class;
static CLASS_ATTR(Update, 0666, NULL, set_mcu_update);
static CLASS_ATTR(SpiritEnableAutopower, 0666, get_mcu_state_autopower, set_mcu_enable_autopower);
static CLASS_ATTR(Verison, 0666, mcu_driver_version, NULL); 
static CLASS_ATTR(SpiritVerison, 0666, spirit_version, NULL); 
static CLASS_ATTR(Watchdog, 0666, get_mcu_state_watchdog, set_mcu_enable_watchdog);
static CLASS_ATTR(Watchdog_test, 0666, NULL, set_watchdog_test);
static CLASS_ATTR(Rtcpower, 0666, get_mcu_state_rtcpower, set_mcu_enable_rtcpower);
static CLASS_ATTR(EthWol, 0666, get_mcu_state_ethwol, set_mcu_enable_ethwol);


//add spirit class e------------------------

int jw_mcu_get_cc_status(u8 *role, u8 *direction){
	u8 ret_role,ret_direction;
	int ret;
	ret = Mcu_i2c_readregister(gClient, CORE_ANX7411_CC_ROLE, 1,&ret_role);
	if (ret < 0) {
		printk("jw_mcu_get_cc_status read fail\n");
		return -EINVAL;
	}
	ret = Mcu_i2c_readregister(gClient, CORE_ANX7411_CC_DIRECTION, 1,&ret_direction);
	if (ret < 0) {
		printk("jw_mcu_get_cc_status read fail\n");
		return -EINVAL;
	}
	printk("jw_mcu_get_cc_status ret_role=%d,ret_direction=%d---ison\n",ret_role,ret_direction);
	*role = ret_role;
	*direction = ret_direction;
	return ret;
}


void MCU_Set_EthPhyAddr(char *addr){
	int ret = 0,i;
	//u8 tmp =0;
	char *addr_l = addr;
	for(i = 0;i < 6;i++){
		printk("MCU_Set_EthPhyAddr  %d------------ison\n",addr_l[i]);
		ret = Mcu_i2c_writeregister(gClient, CORE_ETH_PHY_ADDR0 + i, 1, addr_l[i]);
		if (ret < 0) {
			printk("Mcu_i2c_writeregister fail\n");
			return;
		}
	}
}
///////////////andy add 

static int rtl8211_phy_power_off(struct notifier_block *this,
                    unsigned long code, void *unused)
{
	u8 ethwol_power=0,tmp;
	int ret = 0;

    if (code == SYS_POWER_OFF){
		ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,&ethwol_power);
		if (ret < 0) {
			printk("Mcu_i2c_readregister fail\n");
			return -1;
		}	
		tmp = set_value_func_cfg(CORE_FUNC_PWR_OFF_EN,ethwol_power,0);
		ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
		if (ret < 0) {
			printk("Mcu_i2c_writeregister fail\n");
			return -1;
		}		
		printk("write power off message to mcu   ------------andy\n");		
	}
    return NOTIFY_OK;
}
////////////////andy end
static struct notifier_block rtl8211_phy_notifier = {
        .notifier_call = rtl8211_phy_power_off,
};


static int  jw_mcu_probe(struct i2c_client *client, const struct i2c_device_id *id)

{
    int ret = 0, err;
	u8 read_mcu_id=0,ethwol_power=0,tmp;
	//char tmp1[2];
	//enum of_gpio_flags flags;
	node_MCU = client->dev.of_node;
	dev_MCU = &client->dev;
	gClient = client;
    printk("%s \n",__FUNCTION__);

    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
        printk(KERN_ERR "jw_mcu_probe: need I2C_FUNC_I2C\n");
        ret = -ENODEV;
    }
//ison s
#if 1
	ret=Mcu_i2c_readregister(client, CORE_FW_VERSION, 1,&read_mcu_id);
	if (ret < 0) {
		printk("jw_mcu read fail\n");
		return -EINVAL;
	}
	printk("Mcu_i2c_readregister 1 read1 = %d ------------ison\n",read_mcu_id);
#endif
//ison e



	spirit_class = class_create(THIS_MODULE, "spirit_class");
	if (IS_ERR(spirit_class)) {
		printk(KERN_ERR "Failed to create spirit_class\n");
		spirit_class = NULL;
		return -EINVAL;
	}	
	
	ret =  class_create_file(spirit_class, &class_attr_Update);
	ret =  class_create_file(spirit_class, &class_attr_SpiritEnableAutopower);
	ret =  class_create_file(spirit_class, &class_attr_Verison);
	ret =  class_create_file(spirit_class, &class_attr_SpiritVerison);
	ret =  class_create_file(spirit_class, &class_attr_Watchdog);
	ret =  class_create_file(spirit_class, &class_attr_Watchdog_test);
	ret =  class_create_file(spirit_class, &class_attr_Rtcpower);
	ret =  class_create_file(spirit_class, &class_attr_EthWol);
	
	watchdog_init();

	err = register_reboot_notifier(&rtl8211_phy_notifier);
	if (err) {
    	printk("unable to register jw_mcu_probe reboot notifier\n");
	}	

///////////////andy add 
	ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,&ethwol_power);
	if (ret < 0) {
		printk("Mcu_i2c_readregister fail\n");
		return -1;
	}	
	tmp = set_value_func_cfg(CORE_FUNC_PWR_OFF_EN,ethwol_power,1);

	ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
	if (ret < 0) {
		printk("Mcu_i2c_writeregister fail\n");
		return -1;
	}

/////////////andy end		

	printk("%s: probe ok!!\n", __FUNCTION__);


	
    return 0;
	
}


static const struct i2c_device_id jw_mcu_id[] = {
	{ "jw_mcu", 0 },
	{ }
};

static const struct of_device_id jw_mcu_of_match[] = {
	{ .compatible = "everest,jw_mcu", },
	{ }
};
MODULE_DEVICE_TABLE(of, jw_mcu_of_match);


static struct i2c_driver jw_mcu_driver = {
	.driver		= {
		.name	= "jw_mcu",
		.of_match_table = of_match_ptr(jw_mcu_of_match),
	},
	.probe		= jw_mcu_probe,
 	.id_table	= jw_mcu_id,
	//.remove		= __devexit_p(cec_input_control_remove),
};

module_i2c_driver(jw_mcu_driver);
MODULE_AUTHOR("ison@jwele.com.cn");
MODULE_DESCRIPTION("jw mcu driver");
MODULE_LICENSE("GPL");