#include <linux/module.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/kernel.h>

#include <linux/uaccess.h>
#include "../init-input.h"

#define ALLWINNER_PLATFORM
//#define ACTIONS_PLATFORM
#ifdef ALLWINNER_PLATFORM
#include <linux/sys_config.h>
#endif

// device info
#define SENSOR_NAME                   "sc7a30"
#define SENSOR_I2C_ADDR               0x1D
#define ABSMIN                              -512
#define ABSMAX                             512
#define FUZZ                                 2
#define LSG                                  64
#define MAX_DELAY                       200

// constant define
#define SC7A30_CHIP_ID                0x2A
#define SC7A30_DATA_READY        0x07

#define SC7A30_RANGE_2G             0x00
#define SC7A30_RANGE_8G             0x01

#define SC7A30_MODE_STANDBY       0x07
#define SC7A30_MODE_ACTIVE        0x47

#define SC7A30_RATE_400HZ           0x00
#define SC7A30_RATE_100HZ           0x01

// register define
#define SC7A30_XOUT			0x29
#define SC7A30_YOUT			0x2B
#define SC7A30_ZOUT			0x2D
#define SC7A30_MODE_REG			0x20
#define SC7A30_MODE1			0x21
#define SC7A30_MODE2			0x22
#define SC7A30_STATUS			0x27
#define SC7A30_WU_CFG                0X30
#define SC7A30_WU_SRC                0X31
#define SC7A30_WU_THS                0X32
#define SC7A30_WU_DUTATION               0X33

#define POLL_INTERVAL_MAX	500
#define POLL_INTERVAL		50
#define INPUT_FUZZ	2
#define INPUT_FLAT	2
#define SENSORS_INONE	0


#define MODE_CHANGE_DELAY_MS 100

// register bits define
#define SC7A30_RANGE_BIT__POS            7
#define SC7A30_RANGE_BIT__LEN            1
#define SC7A30_RANGE_BIT__MSK            0x20
#define SC7A30_RANGE_BIT__REG            SC7A30_MODE_REG

#define SC7A30_MODE_BIT__POS            0
#define SC7A30_MODE_BIT__LEN            7
#define SC7A30_MODE_BIT__MSK            0x47
#define SC7A30_MODE_BIT__REG            SC7A30_MODE_REG

#define SC7A30_RATE_BIT__POS            5
#define SC7A30_RATE_BIT__LEN            1
#define SC7A30_RATE_BIT__MSK            0x80
#define SC7A30_RATE_BIT__REG            SC7A30_MODE_REG


#define SC7A30_GET_BITSLICE(regvar, bitname)\
    ((regvar & bitname##__MSK) >> bitname##__POS)

#define SC7A30_SET_BITSLICE(regvar, bitname, val)\
    ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))

static struct sensor_config_info gsensor_info = {
	.input_type = GSENSOR_TYPE,
};

struct SC7A30_acc{
    s16    x;
    s16    y;
    s16    z;
} ;

struct SC7A30_data {
    struct i2c_client *SC7A30_client;
    struct input_dev *input;
    atomic_t delay;
    atomic_t enable;
    struct mutex enable_mutex;
    struct delayed_work work;
#ifdef CONFIG_HAS_EARLYSUSPEND
    struct early_suspend early_suspend;
#endif
    atomic_t position;
    atomic_t calibrated;
    atomic_t fuzz;
     int offset[3];
};

// cfg data : 1-- used
#define CFG_GSENSOR_USE_CONFIG  1

// calibration file path
#define CFG_GSENSOR_CALIBFILE   "/data/data/com.actions.sensor.calib/files/gsensor_calib.txt"

/*******************************************
* for xml cfg
*******************************************/
#ifdef ACTIONS_PLATFORM
#define CFG_GSENSOR_ADAP_ID          "gsensor.i2c_adap_id"
#define CFG_GSENSOR_POSITION         "gsensor.position"
#define CFG_GSENSOR_CALIBRATION      "gsensor.calibration"
#define CFG_GSENSOR_MOD_POSITION   "gsensor_"SENSOR_NAME".position"
extern int get_config(const char *key, char *buff, int len);
#endif

#ifdef ALLWINNER_PLATFORM
//static union{
//	unsigned short dirty_addr_buf[2];
//	const unsigned short normal_i2c[2];
//}u_i2c_addr = {{0x00},{SENSOR_I2C_ADDR, I2C_CLIENT_END}};
static __u32 twi_id = 0;
static int sc7a30_pin_hd;
#endif
/*******************************************
* end for xml cfg
*******************************************/

//#ifdef CONFIG_HAS_EARLYSUSPEND
//static void SC7A30_early_suspend(struct early_suspend *h);
//static void SC7A30_early_resume(struct early_suspend *h);
//#endif

#ifdef ALLWINNER_PLATFORM
/**
 * gsensor_fetch_sysconfig_para - get config info from sysconfig.fex file.
 * return value:  
 *                    = 0; success;
 *                    < 0; err
 */
/*static int gsensor_fetch_sysconfig_para(void)
{
											
	int ret = -1;
	int device_used = -1;
	__u32 twi_addr = 0;
	char name[I2C_NAME_SIZE];
	script_parser_value_type_t type = SCIRPT_PARSER_VALUE_TYPE_STRING;

	printk("========%s===================\n", __func__);

#if(SENSORS_INONE)
	if(SCRIPT_PARSER_OK != (ret = script_parser_fetch("gsensor_para1", "gsensor_used", &device_used, 1))){
		pr_err("%s: script_parser_fetch err.ret = %d. \n", __func__, ret);
		goto script_parser_fetch_err;
	}
#else
	if(SCRIPT_PARSER_OK != (ret = script_parser_fetch("gsensor_para", "gsensor_used", &device_used, 1))){
		pr_err("%s: script_parser_fetch err.ret = %d. \n", __func__, ret);
		goto script_parser_fetch_err;
	}
#endif
	if(1 == device_used){
#if(SENSORS_INONE)
		if(SCRIPT_PARSER_OK != script_parser_fetch_ex("gsensor_para1", "gsensor_name", (int *)(&name), &type, sizeof(name)/sizeof(int))){
			pr_err("%s: line: %d script_parser_fetch err. \n", __func__, __LINE__);
			goto script_parser_fetch_err;
		}
#else
		if(SCRIPT_PARSER_OK != script_parser_fetch_ex("gsensor_para", "gsensor_name", (int *)(&name), &type, sizeof(name)/sizeof(int))){
			pr_err("%s: line: %d script_parser_fetch err. \n", __func__, __LINE__);
			goto script_parser_fetch_err;
		}
#endif
		if(strcmp(SENSOR_NAME, name)){
			pr_err("%s: name %s does not match SENSOR_NAME. \n", __func__, name);
			pr_err(SENSOR_NAME);
			//ret = 1;
			return ret;
		}
#if(SENSORS_INONE)		
		if(SCRIPT_PARSER_OK != script_parser_fetch("gsensor_para1", "gsensor_twi_addr", &twi_addr, sizeof(twi_addr)/sizeof(__u32))){
			pr_err("%s: line: %d: script_parser_fetch err. \n", name, __LINE__);
			goto script_parser_fetch_err;
		}
#else
		if(SCRIPT_PARSER_OK != script_parser_fetch("gsensor_para", "gsensor_twi_addr", &twi_addr, sizeof(twi_addr)/sizeof(__u32))){
			pr_err("%s: line: %d: script_parser_fetch err. \n", name, __LINE__);
			goto script_parser_fetch_err;
		}
#endif
		u_i2c_addr.dirty_addr_buf[0] = twi_addr;
		u_i2c_addr.dirty_addr_buf[1] = I2C_CLIENT_END;
		printk("%s: after: gsensor_twi_addr is 0x%x, dirty_addr_buf: 0x%hx. dirty_addr_buf[1]: 0x%hx \n", \
				__func__, twi_addr, u_i2c_addr.dirty_addr_buf[0], u_i2c_addr.dirty_addr_buf[1]);
#if(SENSORS_INONE)
		if(SCRIPT_PARSER_OK != script_parser_fetch("gsensor_para1", "gsensor_twi_id", &twi_id, 1)){
			pr_err("%s: script_parser_fetch err. \n", name);
			goto script_parser_fetch_err;
		}
#else
		if(SCRIPT_PARSER_OK != script_parser_fetch("gsensor_para", "gsensor_twi_id", &twi_id, 1)){
			pr_err("%s: script_parser_fetch err. \n", name);
			goto script_parser_fetch_err;
		}
#endif
		printk("%s: twi_id is %d. \n", __func__, twi_id);
#if(SENSORS_INONE)
		sc7a30_pin_hd = gpio_request_ex("gsensor_para1",NULL);
#else
		sc7a30_pin_hd = gpio_request_ex("gsensor_para",NULL);
#endif
		if (sc7a30_pin_hd==-1) {
			printk("sc7a30 pin request error!\n");
		}
		ret = 0;

	}else{
		pr_err("%s: gsensor_unused. \n",  __func__);
		ret = -1;
	}

	return ret;

script_parser_fetch_err:
	pr_notice("=========script_parser_fetch_err============\n");
	return ret;
}*/
/**
 * gsensor_detect - Device detection callback for automatic device creation
 * return value:  
 *                    = 0; success;
 *                    < 0; err
 */
int gsensor_detect(struct i2c_client *client, struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = client->adapter;

	if(twi_id == adapter->nr){
		pr_info("%s: Detected chip %s at adapter %d, address 0x%02x\n",
				__func__, SENSOR_NAME, i2c_adapter_id(adapter), client->addr);

		strlcpy(info->type, SENSOR_NAME, I2C_NAME_SIZE);
		return 0;
	}else{
		return -ENODEV;
	}
}
#endif

static int SC7A30_axis_remap(struct i2c_client *client, struct SC7A30_acc *acc);

static int SC7A30_smbus_read_byte(struct i2c_client *client,
        unsigned char reg_addr, unsigned char *data)
{
    s32 dummy;
    dummy = i2c_smbus_read_byte_data(client, reg_addr);
    if (dummy < 0)
        return -1;
    *data = dummy & 0x000000ff;

    return 0;
}

static int SC7A30_smbus_write_byte(struct i2c_client *client,
        unsigned char reg_addr, unsigned char *data)
{
    s32 dummy;
    dummy = i2c_smbus_write_byte_data(client, reg_addr, *data);
    if (dummy < 0)
        return -1;
    return 0;
}

static int SC7A30_smbus_read_byte_block(struct i2c_client *client,
        unsigned char reg_addr, unsigned char *data, unsigned char len)
{
    s32 dummy;
    dummy = i2c_smbus_read_i2c_block_data(client, reg_addr, len, data);
    if (dummy < 0)
        return -1;
    return 0;
}

static int SC7A30_smbus_write_byte_block(struct i2c_client *client,
        unsigned char reg_addr, unsigned char *data, unsigned char len)
{
    s32 dummy;    
    dummy = i2c_smbus_write_i2c_block_data(client, reg_addr, len, data);
        if (dummy < 0)
            return -1;    
    return 0;
}

static int SC7A30_set_mode(struct i2c_client *client, unsigned char mode)
{
    int comres = 0;
    unsigned char data = 0;

    comres = SC7A30_smbus_read_byte(client, SC7A30_MODE_BIT__REG, &data);    
    data  = SC7A30_SET_BITSLICE(data, SC7A30_MODE_BIT, mode);
    comres += SC7A30_smbus_write_byte(client, SC7A30_MODE_BIT__REG, &data);

    return comres;
}

static int SC7A30_get_mode(struct i2c_client *client, unsigned char *mode)
{
    int comres = 0;
    unsigned char data = 0;

    comres = SC7A30_smbus_read_byte(client, SC7A30_MODE_BIT__REG, &data);
    *mode  = SC7A30_GET_BITSLICE(data, SC7A30_MODE_BIT);

    return comres;
}

static int SC7A30_set_range(struct i2c_client *client, unsigned char range)
{
    int comres = 0;
    unsigned char data = 0;
    unsigned char mode;

    // save mode
    comres += SC7A30_smbus_read_byte(client, SC7A30_MODE_BIT__REG, &data);
    mode = SC7A30_GET_BITSLICE(data, SC7A30_MODE_BIT);    
    if (mode == SC7A30_MODE_ACTIVE) {
        data = SC7A30_SET_BITSLICE(data, SC7A30_MODE_BIT, SC7A30_MODE_STANDBY);
        comres += SC7A30_smbus_write_byte(client, SC7A30_MODE_BIT__REG, &data);
    }
    
    comres += SC7A30_smbus_read_byte(client, SC7A30_RANGE_BIT__REG, &data);    
    data  = SC7A30_SET_BITSLICE(data, SC7A30_RANGE_BIT, range);
    comres += SC7A30_smbus_write_byte(client, SC7A30_RANGE_BIT__REG, &data);

    // restore mode
    if (mode == SC7A30_MODE_ACTIVE) {
        comres += SC7A30_smbus_read_byte(client, SC7A30_MODE_BIT__REG, &data);
        data = SC7A30_SET_BITSLICE(data, SC7A30_MODE_BIT, SC7A30_MODE_ACTIVE);
        comres += SC7A30_smbus_write_byte(client, SC7A30_MODE_BIT__REG, &data);
    }
    
    return comres;
}

static int SC7A30_get_range(struct i2c_client *client, unsigned char *range)
{
    int comres = 0;
    unsigned char data = 0;

    comres = SC7A30_smbus_read_byte(client, SC7A30_RANGE_BIT__REG, &data);
    *range  = SC7A30_GET_BITSLICE(data, SC7A30_RANGE_BIT);

    return comres;
}

static int SC7A30_set_rate(struct i2c_client *client, unsigned char rate)
{
    int comres = 0;
    unsigned char data = 0;
    unsigned char mode;

    // save mode
    comres += SC7A30_smbus_read_byte(client, SC7A30_MODE_BIT__REG, &data);
    mode = SC7A30_GET_BITSLICE(data, SC7A30_MODE_BIT);    
    if (mode == SC7A30_MODE_ACTIVE) {
        data = SC7A30_SET_BITSLICE(data, SC7A30_MODE_BIT, SC7A30_MODE_STANDBY);
        comres += SC7A30_smbus_write_byte(client, SC7A30_MODE_BIT__REG, &data);
    }
    
    comres += SC7A30_smbus_read_byte(client, SC7A30_RATE_BIT__REG, &data);    
    data = SC7A30_SET_BITSLICE(data, SC7A30_RATE_BIT, rate);
    comres += SC7A30_smbus_write_byte(client, SC7A30_RATE_BIT__REG, &data);

    // restore mode
    if (mode == SC7A30_MODE_ACTIVE) {
        comres += SC7A30_smbus_read_byte(client, SC7A30_MODE_BIT__REG, &data);
        data = SC7A30_SET_BITSLICE(data, SC7A30_MODE_BIT, SC7A30_MODE_ACTIVE);
        comres += SC7A30_smbus_write_byte(client, SC7A30_MODE_BIT__REG, &data);
    }
    
    return comres;
}

static int SC7A30_get_rate(struct i2c_client *client, unsigned char *rate)
{
    int comres = 0;
    unsigned char data = 0;

    comres = SC7A30_smbus_read_byte(client, SC7A30_RATE_BIT__REG, &data);
    *rate  = SC7A30_GET_BITSLICE(data, SC7A30_RATE_BIT);

    return comres;
}


static int SC7A30_hw_init(struct i2c_client *client)
{
    int comres = 0;    
    // sample rate: 100Hz
    comres += SC7A30_set_rate(client, SC7A30_RATE_100HZ);
    
    // range: -2G~+2G
    comres += SC7A30_set_range(client, SC7A30_RANGE_2G);
    
    return comres;
}

static int SC7A30_read_data(struct i2c_client *client, struct SC7A30_acc *acc)
{
   s8 px,py,pz; 
   s32 result;
   result=i2c_smbus_read_byte_data(client, SC7A30_XOUT);
   px=result&0xff;
   result=i2c_smbus_read_byte_data(client, SC7A30_YOUT);
   py=result&0xff;
   result=i2c_smbus_read_byte_data(client, SC7A30_ZOUT);
   pz=result&0xff;	
   acc->x = (((short)px) << 8) >> 8;
   acc->y = (((short)py) << 8) >> 8;
   acc->z = (((short)pz) << 8) >> 8;
   //printk("pga_debug\n");
   return 0;
}

static ssize_t SC7A30_register_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    int address, value;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    sscanf(buf, "[0x%x]=0x%x", &address, &value);    
    if (SC7A30_smbus_write_byte(SC7A30->SC7A30_client, (unsigned char)address,
                (unsigned char *)&value) < 0)
        return -EINVAL;

    return count;
}

static ssize_t SC7A30_register_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);    
    size_t count = 0;
    u8 reg[0x32];
    int i;
    
    for (i = 0 ; i < 0x32; i++) {
        SC7A30_smbus_read_byte(SC7A30->SC7A30_client, i, reg+i);    
        count += sprintf(&buf[count], "0x%x: 0x%x\n", i, reg[i]);
    }
    
    return count;
}

static ssize_t SC7A30_mode_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    unsigned char data;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    if (SC7A30_get_mode(SC7A30->SC7A30_client, &data) < 0)
        return sprintf(buf, "Read error\n");

    return sprintf(buf, "%d\n", data);
}

static ssize_t SC7A30_mode_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    unsigned long data;
    int error;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    error = strict_strtoul(buf, 10, &data);
    if (error)
        return error;
    if (SC7A30_set_mode(SC7A30->SC7A30_client, (unsigned char) data) < 0)
        return -EINVAL;

    return count;
}

static ssize_t SC7A30_rate_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    unsigned char data;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    if (SC7A30_get_rate(SC7A30->SC7A30_client, &data) < 0)
        return sprintf(buf, "Read error\n");

    return sprintf(buf, "%d\n", data);
}

static ssize_t SC7A30_rate_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    unsigned long data;
    int error;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    error = strict_strtoul(buf, 10, &data);
    if (error)
        return error;
    if (SC7A30_set_rate(SC7A30->SC7A30_client, (unsigned char) data) < 0)
        return -EINVAL;

    return count;
}

static ssize_t SC7A30_value_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct input_dev *input = to_input_dev(dev);
    struct SC7A30_data *SC7A30 = input_get_drvdata(input);
    struct SC7A30_acc acc;
    int result;
    int retry = 10;

    while (retry > 0) {
        result = SC7A30_read_data(SC7A30->SC7A30_client, &acc);
        if (result == 0) {
            break;
        }
        retry = retry - 1;
        msleep(20);
    }
    
    if (result == 0) {
        SC7A30_axis_remap(SC7A30->SC7A30_client, &acc);    
        return sprintf(buf, "%d %d %d\n", acc.x, acc.y, acc.z);
    } else {
        return sprintf(buf, "SC7A30_read_data failed!\n");
    }
}

static ssize_t SC7A30_delay_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    return sprintf(buf, "%d\n", atomic_read(&SC7A30->delay));

}

static ssize_t SC7A30_delay_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    unsigned long data;
    unsigned char rate;
    int error;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    error = strict_strtoul(buf, 10, &data);
    if (error)
        return error;

    if (data > MAX_DELAY) {
        data = MAX_DELAY;
    }
    
    atomic_set(&SC7A30->delay, (unsigned int) data);

    // change sample rate
    data = 1000 / data;
    if (data > 200) {
        rate = SC7A30_RATE_400HZ;
    } else if (data > 50) {
        rate = SC7A30_RATE_100HZ;
    }else {
        rate = SC7A30_RATE_100HZ;
    }
    SC7A30_set_rate(SC7A30->SC7A30_client, rate);  
    return count;
}


static ssize_t SC7A30_enable_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    return sprintf(buf, "%d\n", atomic_read(&SC7A30->enable));

}

static void SC7A30_do_enable(struct device *dev, int enable)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    if (enable) {
        SC7A30_set_mode(SC7A30->SC7A30_client, SC7A30_MODE_ACTIVE);
        schedule_delayed_work(&SC7A30->work,
            msecs_to_jiffies(atomic_read(&SC7A30->delay)));
    } else {
        SC7A30_set_mode(SC7A30->SC7A30_client, SC7A30_MODE_STANDBY);
        cancel_delayed_work_sync(&SC7A30->work);
    }
}

static void SC7A30_set_enable(struct device *dev, int enable)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);
	int pre_enable = atomic_read(&SC7A30->enable);

    mutex_lock(&SC7A30->enable_mutex);
    if (enable != pre_enable) {
        SC7A30_do_enable(dev, enable);
        atomic_set(&SC7A30->enable, enable);
    }
    mutex_unlock(&SC7A30->enable_mutex);
}

static ssize_t SC7A30_enable_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    unsigned long data;
    int error;

    error = strict_strtoul(buf, 10, &data);
    if (error)
        return error;
    if ((data == 0) || (data == 1))
        SC7A30_set_enable(dev, data);

    return count;
}

static ssize_t SC7A30_fuzz_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    return sprintf(buf, "%d\n", atomic_read(&SC7A30->fuzz));

}

static ssize_t SC7A30_fuzz_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    unsigned long data;
    int error;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    error = strict_strtoul(buf, 10, &data);
    if (error)
        return error;
    
    atomic_set(&(SC7A30->fuzz), (int) data);
    
    if(SC7A30->input != NULL) {
        SC7A30->input->absinfo[ABS_X].fuzz = data;
        SC7A30->input->absinfo[ABS_Y].fuzz = data;
        SC7A30->input->absinfo[ABS_Z].fuzz = data;
    }

    return count;
}

static ssize_t SC7A30_board_position_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    int data;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    data = atomic_read(&(SC7A30->position));

    return sprintf(buf, "%d\n", data);
}

static ssize_t SC7A30_board_position_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    unsigned long data;
    int error;
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    error = strict_strtol(buf, 10, &data);
    if (error)
        return error;

    atomic_set(&(SC7A30->position), (int) data);

    return count;
}

static ssize_t SC7A30_calibration_run_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);
    struct SC7A30_acc acc;
  	long xyz[3]={0};
    int result,i;
    int retry = 16;
     for(i=0;i<retry;i++)
	 {
      result = SC7A30_read_data(SC7A30->SC7A30_client, &acc);
        xyz[0]+=acc.x;
        xyz[1]+=acc.y;
        xyz[2]+=acc.z;
	 }
	  acc.x=xyz[0]/retry;
	  acc.y=xyz[1]/retry;
	  acc.z=xyz[2]/retry;
	if (acc.z > 0) {
      acc.z -= LSG;
    } 
	else {
        acc.z += LSG;
    }
	/* 
    while (retry > 0) {
        result = SC7A30_read_data(SC7A30->SC7A30_client, &acc);
        if (result == 0) {
            break;
        }
        retry = retry - 1;
        msleep(20);
    }

    if (result == 0) {   
        printk(KERN_INFO "data: %d %d %d\n", acc.x, acc.y, acc.z);
    } else {
        printk(KERN_INFO "run calibration failed!\n");     
        return count;
    }
    
    acc.x = (0 - acc.x) / 2;
    acc.y = (0 - acc.y) / 2;
    if (atomic_read(&SC7A30->position) > 0) {
        acc.z = (LSG - acc.z) / 2;
    } else {
        acc.z = ((-LSG) - acc.z) / 2;
    }
    */
    printk(KERN_INFO "calibration: %d %d %d\n", acc.x, acc.y, acc.z);

    SC7A30->offset[0] = acc.x;
    SC7A30->offset[1] = acc.y;
    SC7A30->offset[2] = acc.z;
    printk(KERN_INFO "run calibration finished\n");
    return count;
}

static ssize_t SC7A30_calibration_reset_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);
    
    memset(&(SC7A30->offset), 0, sizeof(SC7A30->offset));    
    printk(KERN_INFO "reset calibration finished\n");
    return count;
}

static ssize_t SC7A30_calibration_value_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    return sprintf(buf, "%d %d %d\n", SC7A30->offset[0], 
                                SC7A30->offset[1], SC7A30->offset[2]);
}

static ssize_t SC7A30_calibration_value_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    int data[3];
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);

    sscanf(buf, "%d %d %d", &data[0], &data[1], &data[2]);
    SC7A30->offset[0] = data[0];
    SC7A30->offset[1] = data[1];
    SC7A30->offset[2] = data[2];    
    printk(KERN_INFO "set calibration finished\n");
    return count;
}

static DEVICE_ATTR(reg, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_register_show, SC7A30_register_store);
static DEVICE_ATTR(mode, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_mode_show, SC7A30_mode_store);
static DEVICE_ATTR(rate, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_rate_show, SC7A30_rate_store);
static DEVICE_ATTR(value, 0666,//S_IRUGO,
        SC7A30_value_show, NULL);
static DEVICE_ATTR(delay, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_delay_show, SC7A30_delay_store);
static DEVICE_ATTR(enable, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_enable_show, SC7A30_enable_store);
static DEVICE_ATTR(fuzz, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_fuzz_show, SC7A30_fuzz_store);
static DEVICE_ATTR(board_position, 0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_board_position_show, SC7A30_board_position_store);
static DEVICE_ATTR(calibration_run, 0666,//S_IWUSR|S_IWGRP, //calibration_run
        NULL, SC7A30_calibration_run_store);
static DEVICE_ATTR(calibration_reset, 0666,//S_IWUSR|S_IWGRP,
        NULL, SC7A30_calibration_reset_store);
static DEVICE_ATTR(calibration_value,0666,//S_IRUGO|S_IWUSR|S_IWGRP,
        SC7A30_calibration_value_show,
        SC7A30_calibration_value_store);

static struct attribute *SC7A30_attributes[] = {
    &dev_attr_reg.attr,
    &dev_attr_mode.attr,    
    &dev_attr_rate.attr,
    &dev_attr_value.attr,
    &dev_attr_delay.attr,
    &dev_attr_enable.attr,
    &dev_attr_fuzz.attr,
    &dev_attr_board_position.attr,
    &dev_attr_calibration_run.attr,
    &dev_attr_calibration_reset.attr,
    &dev_attr_calibration_value.attr,
    NULL
};

static struct attribute_group SC7A30_attribute_group = {
    .attrs = SC7A30_attributes
};

static int SC7A30_read_file(char *path, char *buf, int size)
{
    struct file *filp;
    loff_t len, offset;
    int ret=0;
    mm_segment_t fs;

    filp = filp_open(path, O_RDWR, 0777);
    if (IS_ERR(filp)) {
        ret = PTR_ERR(filp);
        goto out;
    }

    len = vfs_llseek(filp, 0, SEEK_END);
    if (len > size) {
        len = size;
    }
    
    offset = vfs_llseek(filp, 0, SEEK_SET);

    fs=get_fs();
    set_fs(KERNEL_DS);

    ret = vfs_read(filp, (char __user *)buf, (size_t)len, &(filp->f_pos));

    set_fs(fs);

    filp_close(filp, NULL);    
out:
    return ret;
}

static int SC7A30_load_user_calibration(struct i2c_client *client)
{
    char buffer[16];
    int ret = 0;
    int data[3];
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);    
    int calibrated = atomic_read(&SC7A30->calibrated);
    
    // only calibrate once
    if (calibrated) {
        goto usr_calib_end;
    } else {
        atomic_set(&SC7A30->calibrated, 1);
    }

    ret = SC7A30_read_file(CFG_GSENSOR_CALIBFILE, buffer, sizeof(buffer));
    if (ret <= 0) {
        printk(KERN_ERR "gsensor calibration file not exist!\n");
        goto usr_calib_end;
    }
    
    sscanf(buffer, "%d %d %d", &data[0], &data[1], &data[2]);
    SC7A30->offset[0] = data[0];
    SC7A30->offset[1] = data[1];
    SC7A30->offset[2] = data[2];    
    printk(KERN_INFO "user cfg_calibration: %d %d %d\n", data[0], data[1], data[2]);
    
usr_calib_end:
    return ret;
}

static int SC7A30_axis_remap(struct i2c_client *client, struct SC7A30_acc *acc)
{
    s16 swap;
    struct SC7A30_data *SC7A30 = i2c_get_clientdata(client);
    int position = atomic_read(&SC7A30->position);

    switch (abs(position)) {
        case 1:
            swap = acc->x;
            acc->x = acc->y;
            acc->y = -swap; 
            break;
        case 2:
            acc->x = -(acc->x);
            acc->y = -(acc->y);
            break;
        case 3:
            swap = acc->x;
            acc->x = -acc->y;
            acc->y = swap;
            break;
        case 4:
            break;
    }
    
    if (position < 0) {
        acc->z = -(acc->z);
        acc->x = -(acc->x);
    }
    
    return 0;
}

static void SC7A30_work_func(struct work_struct *work)
{
    struct SC7A30_data *SC7A30 = container_of((struct delayed_work *)work,
            struct SC7A30_data, work);
    static struct SC7A30_acc acc;    
    int result;
    unsigned long delay = msecs_to_jiffies(atomic_read(&SC7A30->delay));
    
    SC7A30_load_user_calibration(SC7A30->SC7A30_client);
	
    result = SC7A30_read_data(SC7A30->SC7A30_client, &acc);
	acc.x-=SC7A30->offset[0];
	acc.y-=SC7A30->offset[1];
	acc.z-=SC7A30->offset[2];
    if (result == 0) {		
        SC7A30_axis_remap(SC7A30->SC7A30_client, &acc);
        
        input_report_abs(SC7A30->input, ABS_X, acc.x);
        input_report_abs(SC7A30->input, ABS_Y, -acc.y);
        input_report_abs(SC7A30->input, ABS_Z, acc.z);		
        input_sync(SC7A30->input);
    }

    schedule_delayed_work(&SC7A30->work, delay);
}

static int SC7A30_probe(struct i2c_client *client,
        const struct i2c_device_id *id)
{
    int err = 0;
    struct SC7A30_data *data;
    struct input_dev *dev;
    int cfg_position;
    int cfg_calibration[3];	
	
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
        printk(KERN_INFO "i2c_check_functionality error\n");
        goto exit;
    }
    data = kzalloc(sizeof(struct SC7A30_data), GFP_KERNEL);
    if (!data) {
        err = -ENOMEM;
        goto exit;
    }
    i2c_set_clientdata(client, data);
    data->SC7A30_client = client;
    mutex_init(&data->enable_mutex);

    dev = input_allocate_device();
    if (!dev)
        return -ENOMEM;
    dev->name = SENSOR_NAME;
    dev->id.bustype = BUS_I2C;

    input_set_capability(dev, EV_ABS, ABS_MISC);
    input_set_abs_params(dev, ABS_X, ABSMIN, ABSMAX, FUZZ, 0);
    input_set_abs_params(dev, ABS_Y, ABSMIN, ABSMAX, FUZZ, 0);
    input_set_abs_params(dev, ABS_Z, ABSMIN, ABSMAX, FUZZ, 0);
    input_set_drvdata(dev, data);

    err = input_register_device(dev);
    if (err < 0) {
        input_free_device(dev);
        goto kfree_exit;
    }

    data->input = dev;

    INIT_DELAYED_WORK(&data->work, SC7A30_work_func);
    atomic_set(&data->delay, MAX_DELAY);
#ifdef ALLWINNER_PLATFORM
	SC7A30_set_enable(&client->dev, 1);
#endif
#ifdef ACTIONS_PLATFORM
    atomic_set(&data->enable, 0);
#endif

#ifdef ACTIONS_PLATFORM
#if CFG_GSENSOR_USE_CONFIG > 0
        /*get xml cfg*/
        err = get_config(CFG_GSENSOR_MOD_POSITION, (char *)(&cfg_position), sizeof(int));
        if (err != 0) {
            err = get_config(CFG_GSENSOR_POSITION, (char *)(&cfg_position), sizeof(int));
            if (err != 0) {
                printk(KERN_ERR"get position %d fail\n", cfg_position);
                goto kfree_exit;
            }
        }
#else
        cfg_position = -3;
#endif
#else
            cfg_position = -3;
#endif
    atomic_set(&data->position, cfg_position);
    atomic_set(&data->calibrated, 0);
    atomic_set(&data->fuzz, FUZZ);
        
    //power on init regs    
    err = SC7A30_hw_init(client); 
    if (err < 0) {
        printk(KERN_ERR"SC7A30 probe fail! err:%d\n", err);
        goto kfree_exit;
    }

    err = sysfs_create_group(&data->input->dev.kobj,
            &SC7A30_attribute_group);
    if (err < 0)
        goto error_sysfs;

//#ifdef CONFIG_HAS_EARLYSUSPEND	
//    data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
//    data->early_suspend.suspend = SC7A30_early_suspend;
//    data->early_suspend.resume = SC7A30_early_resume;
//    register_early_suspend(&data->early_suspend);
//#endif

#ifdef ACTIONS_PLATFORM
#if CFG_GSENSOR_USE_CONFIG > 0
    /*get xml cfg*/
    err = get_config(CFG_GSENSOR_CALIBRATION, (char *)cfg_calibration, sizeof(cfg_calibration));
    if (err != 0) {
        printk(KERN_ERR"get calibration fail\n");
        goto error_sysfs;
    }
#else
    memset(cfg_calibration, 0, sizeof(cfg_calibration));
#endif  
#else
    memset(cfg_calibration, 0, sizeof(cfg_calibration));
#endif
    
    // calibrate offset
    data->offset[0] = (int)cfg_calibration[0];
    data->offset[1] = (int)cfg_calibration[1];
    data->offset[2] = (int)cfg_calibration[2];     
    return 0;

error_sysfs:
    input_unregister_device(data->input);

kfree_exit:
    kfree(data);
exit:
    return err;
}

/*#ifdef CONFIG_HAS_EARLYSUSPEND
static void SC7A30_early_suspend(struct early_suspend *h)
{
    // sensor hal will disable when early suspend   
}


static void SC7A30_early_resume(struct early_suspend *h)
{
    // sensor hal will enable when early resume   
}
#endif
*/
static int SC7A30_remove(struct i2c_client *client)
{
    struct SC7A30_data *data = i2c_get_clientdata(client);
	
    SC7A30_set_enable(&client->dev, 0);
//#ifdef CONFIG_HAS_EARLYSUSPEND
//    unregister_early_suspend(&data->early_suspend);
//#endif
    sysfs_remove_group(&data->input->dev.kobj, &SC7A30_attribute_group);
    input_unregister_device(data->input);
    kfree(data);

    return 0;
}

#ifdef CONFIG_PM

static int SC7A30_suspend(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *data = i2c_get_clientdata(client);
    
    SC7A30_do_enable(dev, 0);  
	input_set_power_enable(&(gsensor_info.input_type),0);
    return 0;
}

static int SC7A30_resume(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct SC7A30_data *data = i2c_get_clientdata(client);
    
    //power on init regs    
    SC7A30_hw_init(data->SC7A30_client);
    SC7A30_do_enable(dev, atomic_read(&data->enable));
	input_set_power_enable(&(gsensor_info.input_type),1);
    return 0;
}


#else

#define SC7A30_suspend        NULL
#define SC7A30_resume        NULL

#endif*/ /* CONFIG_PM */


static SIMPLE_DEV_PM_OPS(SC7A30_pm_ops, SC7A30_suspend, SC7A30_resume);

static const unsigned short  SC7A30_addresses[] = {
    SENSOR_I2C_ADDR,
    I2C_CLIENT_END,
};

static const struct i2c_device_id SC7A30_id[] = {
    { SENSOR_NAME, 0 },
    { }
};

MODULE_DEVICE_TABLE(i2c, SC7A30_id);

static const struct of_device_id sc7a30_of_id[] = {
	{ .compatible = "sc7a30",},
	{},
};


static struct i2c_driver SC7A30_driver = {
    .driver = {
        .owner    = THIS_MODULE,
        .name    = SENSOR_NAME,
        .pm    = &SC7A30_pm_ops,
        .of_match_table = "allwinner,sun50i-gsensor-para",
    },
    .class        = I2C_CLASS_HWMON,
    .address_list    = SC7A30_addresses,
    .id_table    = SC7A30_id,
    .probe        = SC7A30_probe, 
    .remove        = SC7A30_remove,   
    
//  #ifdef ALLWINNER_PLATFORM
//  .address_list	= u_i2c_addr.normal_i2c,
//  #endif
};

static struct i2c_board_info SC7A30_board_info={
    .type = SENSOR_NAME, 
    .addr = SENSOR_I2C_ADDR,
};

static struct i2c_client *SC7A30_client;

static int __init SC7A30_init(void)
{
    struct i2c_adapter *i2c_adap;
    unsigned int cfg_i2c_adap_id;
#ifdef ACTIONS_PLATFORM
#if CFG_GSENSOR_USE_CONFIG > 0
    int ret;
    
    /*get xml cfg*/
    ret = get_config(CFG_GSENSOR_ADAP_ID, (char *)(&cfg_i2c_adap_id), sizeof(unsigned int));
    if (ret != 0) {
        printk(KERN_ERR"get i2c_adap_id %d fail\n", cfg_i2c_adap_id);
        return ret;
    }
#else
    cfg_i2c_adap_id = 1;
#endif
#else
    cfg_i2c_adap_id = 1;
	
#endif
#ifdef ACTIONS_PLATFORM
    i2c_adap = i2c_get_adapter(cfg_i2c_adap_id);  
    SC7A30_client = i2c_new_device(i2c_adap, &SC7A30_board_info);  
    i2c_put_adapter(i2c_adap);
#endif
#ifdef ALLWINNER_PLATFORM
   int ret ;
  if (input_fetch_sysconfig_para(&(gsensor_info.input_type))){
	printk("%s: err.\n", __func__);
	return -1;
	}else{
		ret = input_init_platform_resource(&(gsensor_info.input_type));
		if (0 != ret){
			printk("%s:ctp_ops.init_platform_resource err. \n", __func__);
		}
	}
  	input_set_power_enable(&(gsensor_info.input_type),1);
	twi_id = gsensor_info.twi_id;
	printk("%s i2c twi is %d \n", __func__, twi_id);
	SC7A30_driver.detect = gsensor_detect;
	
#endif
    
    return i2c_add_driver(&SC7A30_driver);
}

static void __exit SC7A30_exit(void)
{
  #ifdef ACTIONS_PLATFORM
    i2c_unregister_device(SC7A30_client);
  #endif
    i2c_del_driver(&SC7A30_driver);
    input_free_platform_resource(&(gsensor_info.input_type));
}

MODULE_AUTHOR("zhiyi quan <quanzhiyi@silan.com.cn>");
MODULE_DESCRIPTION("SC7A30 3-Axis Orientation/Motion Detection Sensor driver");
MODULE_LICENSE("GPL");

module_init(SC7A30_init);
module_exit(SC7A30_exit);