/* 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.
 */

//#define DEBUG
//#define pr_fmt(fmt) "rtc: %s: " fmt, __func__
//#include <mach/gpio.h>
//#include <mach/iomux.h>
//#include <mach/board.h>
//#include <plat/board.h>


#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/wakelock.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/reboot.h>
#include "jw_mcu_isp.h"
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#endif

//----------------read bin s
#include <linux/fs.h>
#include <linux/uaccess.h> 
#include <linux/vmalloc.h>
#define ISP_FIRMWARE_FILE_SIZE				(1024*12)
//----------------read bin e

static struct i2c_client *gClient_isp = NULL;
struct device_node *node_MCU_isp = NULL;
struct device *dev_MCU_isp= NULL;
unsigned int pro_1=0;

static unsigned char MCU_ISP_FIRMWARE[]={
#include "jw_mcu_isp.dat"
};


static int Minix_Mcu_write_isp(struct i2c_client *i2c, char *buf,int count)
{
	int ret=-1;
	
	struct i2c_adapter *adap;
	struct i2c_msg msg;

	if(!i2c)
		return ret;
	adap = i2c->adapter;		
	
	msg.addr = i2c->addr;
	msg.buf =(char *)buf;
	msg.len =count;
	msg.flags = i2c->flags;   

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

static ssize_t minixIspUpdateState(struct class *cls,
					struct class_attribute *attr,
					char *buf)
{
	u8 state=1;
	return snprintf(buf, 4, "%02x\n",state);
}
static struct class *minix_isp_class;

static CLASS_ATTR(MCUIspState, 0666, minixIspUpdateState, NULL);

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

{

    int ret = 0;
	int i,lens;
	int count_isp;
	unsigned int pro=0;
	unsigned char MCU_ISP_CMD[64];
	node_MCU_isp = client->dev.of_node; 
	dev_MCU_isp = &client->dev;

    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
        printk(KERN_ERR "isp_probe: need I2C_FUNC_I2C-----------ison\n");
        ret = -ENODEV;
        return ret;
    }

	gClient_isp = client;
//--------------------------------read bin s
count_isp = sizeof(MCU_ISP_FIRMWARE)/sizeof(char);
printk("isp ret = %d-------------ison\n",count_isp);
//----------------------------------------------------------------------
memset(MCU_ISP_CMD,0,64);
MCU_ISP_CMD[0] = CMD_UPDATE_APROM;
ret = Minix_Mcu_write_isp(client, MCU_ISP_CMD, 64);
if (ret < 0) {
	printk("Minix_Mcu_write_isp fail CMD_UPDATE_APROM\n");
	return -ENODEV;
}

msleep(500);

memset(MCU_ISP_CMD,0,64);
MCU_ISP_CMD[0] = CMD_UPDATE_APROM_DATA;
MCU_ISP_CMD[1] = 0;
MCU_ISP_CMD[2] = 0;
MCU_ISP_CMD[3] = 0;

for(i=4;i<64;i++){
	MCU_ISP_CMD[i] = MCU_ISP_FIRMWARE[pro++];
}

ret = Minix_Mcu_write_isp(client, MCU_ISP_CMD, 64);
if (ret < 0) {
	printk("Minix_Mcu_write_isp fail CMD_UPDATE_APROM_DATA\n");
	return -ENODEV;
}

//-------------------------------------------------------------------

msleep(500);

while(pro<count_isp){
	lens = count_isp -pro;
	if( lens > 60){
		memset(MCU_ISP_CMD,0,64);
		MCU_ISP_CMD[0] = CMD_UPDATE_CONTINUOUS;
		MCU_ISP_CMD[1] = 0;
		MCU_ISP_CMD[2] = 0;
		MCU_ISP_CMD[3] = 0;
		for(i=4;i<64;i++){
			MCU_ISP_CMD[i] = MCU_ISP_FIRMWARE[pro++];
		}
		
		ret = Minix_Mcu_write_isp(client, MCU_ISP_CMD, 64);
		if (ret < 0) {
			printk("Minix_Mcu_write_isp fail  CMD_UPDATE_CONTINUOUS\n");
			return -ENODEV;
		}
		
		msleep(10);
	}
	else if(lens < 60){
		
			memset(MCU_ISP_CMD,0,64);
		MCU_ISP_CMD[0] = CMD_UPDATE_CONTINUOUS_END;
		MCU_ISP_CMD[1] = 0;
		MCU_ISP_CMD[2] = 0;
		MCU_ISP_CMD[3] = 0;
		for(i=4;i<lens+4;i++){
			MCU_ISP_CMD[i] = MCU_ISP_FIRMWARE[pro++];
			printk(" %d,",MCU_ISP_CMD[i]);
			
		}
		pro_1 = pro;
		printk("pro = %d-----ison\n",pro_1);
		for(i=lens+4;i<64;i++){
			MCU_ISP_CMD[i] = 0xff;
			pro++;
			}
		
		ret = Minix_Mcu_write_isp(client, MCU_ISP_CMD, 64);
		if (ret < 0) {
			printk("Minix_Mcu_write_isp fail CMD_UPDATE_CONTINUOUS_END\n");
			return -ENODEV;
		}

	}
}

memset(MCU_ISP_CMD,0,64);
MCU_ISP_CMD[0] = CMD_INTER_APROM;

ret = Minix_Mcu_write_isp(client, MCU_ISP_CMD, 64);
if (ret < 0) {
	printk("Minix_Mcu_write_isp fail\n");
	return -ENODEV;
}


	msleep(500);
	minix_isp_class = class_create(THIS_MODULE, "minix-isp");
	if (IS_ERR(minix_isp_class)) {
		printk(KERN_ERR "Failed to create minix isp class\n");
		minix_isp_class = NULL;
		return -EINVAL;
	}
	ret =  class_create_file(minix_isp_class, &class_attr_MCUIspState);

	machine_restart(NULL);
    return 0;
	

}

static const struct i2c_device_id jw_mcu_isp_id[] = {
	{ "jw_mcu_isp", 0 },
	{ }
};

static const struct of_device_id jw_mcu_isp_of_match[] = {
	{ .compatible = "everest,jw_mcu_isp", },
	{ }
};

static struct i2c_driver jw_mcu_isp_driver = {
	.driver		= {
		.name	= "jw_mcu_isp",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(jw_mcu_isp_of_match),
	},
	.probe		= isp_input_control_probe,
 	.id_table	= jw_mcu_isp_id,
};

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