/* 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");
|
