linux/drivers/input/touchscreen/ntp070.c

/* drivers/i2c/chips/ntp070.c - ntp070 compass driver
 *
 * Copyright (C) 2007-2008 HTC Corporation.
 * Author: Hou-Kun Chen <houkun.chen@gmail.com>
 *
 * 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/interrupt.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>
#include <asm/uaccess.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/freezer.h>
#include <mach/gpio.h>
#include <mach/board.h> 
#ifdef CONFIG_ANDROID_POWER
#include <linux/android_power.h>
#endif

//#define RK28_PRINT
//#include <asm/arch/rk28_debug.h>
#if 1
#define rk28printk(x...) printk(x)
#else
#define rk28printk(x...)
#endif

#define LCD_MAX_LENGTH				800
#define LCD_MAX_WIDTH				480

struct ntp070_data{	
	struct input_dev *input_dev;
	struct i2c_client *client;
	int 	irq;
	struct work_struct work;	
};

#define TP_STATE_IDLE         0
#define TP_STATE_DOWN         1

unsigned char tp_state = TP_STATE_IDLE;
static bool irq_finished = true;

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


/* Addresses to scan -- protected by sense_data_mutex */
//static char sense_data[RBUFF_SIZE + 1];
static struct i2c_client *this_client;
struct ntp070_data *g_ts_dev = NULL;

#ifdef CONFIG_ANDROID_POWER
static android_early_suspend_t ntp070_early_suspend;
#endif
static int revision = -1;

//#define TWO_TOUCH_POINT 
#define TOUCH_TP20466A //  ±ÈÑǵÏ

#ifdef TOUCH_TP20466A
#define TOUCH_SPEED		UL(250 * 1000)
#define TOUCHDATA_LEN    (34)
#define TP_MAX_WIDTH				(0x1dba)//7610
#define TP_MAX_LENGTH				(0x12cc)//4812
#define TP_X0  (0xAA)// 170
#define TP_Y0  (0x0E)// 14
static u8 tp20466a_init_data[] =
{
	0x19,0x05,0x06,0x28,0x02,0x14,0x14,0x10,0x28,0xB0,0x14,0x00,0x1E,0x00,0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xE1,0x00,0x00,0x00,0x00,0x4D,0xCF,0x20,0x03,0x03,0x83,0x50,0x3C,0x1E,0xB4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
};
/* write a array of registers  */
//static int TP20466A_write_array(struct i2c_client *client, struct reginfo *regarray)
static int tp20466a_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], __u16 len)//hym8563_i2c_set_regs
{
	int ret;
	ret = i2c_master_reg8_send(client, reg, buf, (int)len, TOUCH_SPEED);
	return ret;
}
#else
#define TOUCH_SPEED		UL(400 * 1000)//
#define TP_MAX_WIDTH				(1266)
#define TP_MAX_LENGTH				(766)
#define TOUCHDATA_LEN    (26)
#endif

/* sensor register read */
static int ntp070_read(struct i2c_client *client, u8 reg, u8 *val)//sensor_read
{
    int err,cnt,i;
    u8 buf[TOUCHDATA_LEN];
    struct i2c_msg msg[1];

    buf[0] = reg & 0xFF;

    msg->addr = client->addr;
    msg->flags = client->flags;
    msg->buf = buf;
    msg->len = 1; //zfl sizeof(buf);
    msg->scl_rate = TOUCH_SPEED;//40*1000;                                        /* ddl@rock-chips.com : 100kHz */
    i2c_transfer(client->adapter, msg, 1);
    msg->addr = client->addr;
    msg->flags = client->flags|I2C_M_RD;
    msg->buf = buf;
    msg->len = TOUCHDATA_LEN; //zfl 1;                                     /* ddl@rock-chips.com : 100kHz */

    cnt = 2;
    err = -EAGAIN;
    while ((cnt--) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */
        err = i2c_transfer(client->adapter, msg, 1);

        if (err >= 0) {
            //zfl *val = buf[0];
            for(i=0;i<TOUCHDATA_LEN;i++)*(val+i) = buf[i];
            return 0;
        } else {
        	printk("\n ntp070_read write reg failed, try to read again!\n");
            udelay(10);
         }
    }

    return err;
}
#if 0 
static int tp20466a_read_test(struct i2c_client *client, u8 reg, u8 *val)//NO
{
    int err,cnt,i;
    u8 buf[TOUCHDATA_LEN];
    struct i2c_msg msg[1];

    buf[0] = reg & 0xFF;

    msg->addr = client->addr;
    msg->flags = client->flags;
    msg->buf = buf;
    msg->len = 1; //zfl sizeof(buf);
    msg->scl_rate = TOUCH_SPEED;//40*1000;                                        /* ddl@rock-chips.com : 100kHz */
    i2c_transfer(client->adapter, msg, 1);
    msg->addr = client->addr;
    msg->flags = client->flags|I2C_M_RD;
    msg->buf = buf;
    msg->len = 1; //zfl 1;                                     /* ddl@rock-chips.com : 100kHz */

    cnt = 5;
    err = -EAGAIN;
    while ((cnt--) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */
        err = i2c_transfer(client->adapter, msg, 1);

        if (err >= 0) {
            //*val = buf[0];
            //for(i=0;i<1;i++)*(val) = buf[i];
        	printk("\n tp20466a_read_test read =0x%x\n",buf[0]);
            return 0;
        } else {
        	printk("\n tp20466a_read_test write reg failed, try to read again!\n");
            udelay(10);
         }
    }

    return err;
}
#endif
static void ntp070_work_func(struct work_struct *work)
{
	struct ntp070_data *ts_dev = g_ts_dev;
	int ak4183_irq_pin_level = 0;
	int ak4183_input_report_flag = 0;
	int xpos, ypos,points,pressure_p0,pressure_p1;
	int ret = 0;	
	unsigned char buf[TOUCHDATA_LEN];
	int x2pos,y2pos,temp;
	int tmpx,tmpy;

#ifdef TOUCH_TP20466A
	ret = ntp070_read(this_client,0x00,buf);
	//if(ret < 0)	goto fake_touch;
	points = buf[0]&0x01 + (buf[0]>>1)&0x01 + (buf[0]>>2)&0x01 + (buf[0]>>3)&0x01 + (buf[0]>>4)&0x01 ;
	ypos = ((unsigned int)buf[2])<<8|(unsigned int)buf[3];
	xpos = ((unsigned int)buf[4])<<8|(unsigned int)buf[5];
	tmpx=xpos;tmpy=ypos;
	pressure_p0 = buf[6];
	if(pressure_p0<2)points=0;
	y2pos = ((unsigned int)buf[7])<<8|(unsigned int)buf[8];
	x2pos = ((unsigned int)buf[9])<<8|(unsigned int)buf[10];
	pressure_p1 = buf[11];
	if(ypos>TP_MAX_LENGTH) { ypos=TP_MAX_LENGTH;points=0;}
	else if(ypos<TP_Y0){ ypos=TP_Y0;points=0;}
	ypos-=TP_Y0;
	ypos=(ypos*(LCD_MAX_WIDTH-1))/(TP_MAX_LENGTH-TP_Y0);ypos=(LCD_MAX_WIDTH-1)-ypos;
	if(xpos>TP_MAX_WIDTH) {xpos=TP_MAX_WIDTH;points=0;}
	else if(xpos<TP_X0) {xpos=TP_X0;points=0;}
	xpos-=TP_X0;
	xpos=(xpos*(LCD_MAX_LENGTH-1))/(TP_MAX_WIDTH-TP_X0);
	rk28printk("buf[0x]=%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7],buf[8],buf[9],buf[10],buf[11]);
	rk28printk("tmpx=0x%x,tmpy=0x%x,press0=%d,press1=%d\n",tmpx,tmpy,pressure_p0,pressure_p1);
#else
	//zfl ret = i2c_master_reg8_recv(this_client,0xF9, buf, 26, TOUCH_SPEED);
	ret = ntp070_read(this_client,0xF9,buf);
	//if(ret < 0)	goto fake_touch;
	ypos = ((unsigned int)buf[5])<<8|(unsigned int)buf[6];
	xpos = ((unsigned int)buf[7])<<8|(unsigned int)buf[8];
	//temp = xpos;//
	//xpos = ypos*800/1280;//
	//ypos = (768 - temp)*480/768;//*/
	y2pos = ((unsigned int)buf[9])<<8|(unsigned int)buf[10];
	x2pos = ((unsigned int)buf[11])<<8|(unsigned int)buf[12];
	points=buf[3];

	if(ypos>TP_MAX_LENGTH) ypos=0;
	else ypos=TP_MAX_LENGTH-ypos;
	ypos=(ypos*(LCD_MAX_WIDTH-1))/TP_MAX_LENGTH;
	if(xpos>TP_MAX_WIDTH) xpos=TP_MAX_WIDTH;
	xpos=(xpos*(LCD_MAX_LENGTH-1))/TP_MAX_WIDTH;
#endif
	if(ret < 0){
		goto fake_touch;
	}
	if(0==points)
	{
		ak4183_irq_pin_level = 1;
		goto fake_touch;
	}
	if(tp_state == TP_STATE_IDLE){
		input_report_key(ts_dev->input_dev, BTN_TOUCH, 1);
		ak4183_input_report_flag = 1;
		tp_state = TP_STATE_DOWN;
	}
		
	if(tp_state == TP_STATE_DOWN){
		input_report_abs(ts_dev->input_dev, ABS_X, xpos);
		input_report_abs(ts_dev->input_dev, ABS_Y, ypos);
#ifdef TOUCH_TP20466A
		//input_report_abs(ts_dev->input_dev, ABS_PRESSURE, pressure_p0);
#endif
		ak4183_input_report_flag = 1;
	}

fake_touch:
	if(ak4183_irq_pin_level == 1 && tp_state == TP_STATE_DOWN){
		input_report_key(ts_dev->input_dev, BTN_TOUCH, 0);
		ak4183_input_report_flag = 1;
		tp_state = TP_STATE_IDLE;
	}

	if(ak4183_input_report_flag != 0)
		input_sync(ts_dev->input_dev);
	rk28printk("%s-point:%d,x:%d,y:%d,x2:%d,y2:%d,tp_state:%d,flag:%d\n\n",__FUNCTION__,points,xpos,ypos,x2pos,y2pos,tp_state,ak4183_input_report_flag);
	enable_irq(ts_dev->irq);
	irq_finished = true;
}

static irqreturn_t ntp070_interrupt(int irq, void *dev_id)
{
	struct ntp070_data *ts_dev = (struct ntp070_data *)dev_id;

	if(!irq_finished)
		return IRQ_HANDLED;
	irq_finished = false;
	disable_irq(ts_dev->irq);
	schedule_work(&ts_dev->work);
	rk28printk("%s:%d\n",__FUNCTION__,__LINE__);
	
	return IRQ_HANDLED;
}

static int ntp070_remove(struct i2c_client *client)
{
	struct ntp070_data *ntp070 = i2c_get_clientdata(client);
	
    input_unregister_device(ntp070->input_dev);
    input_free_device(ntp070->input_dev);
    free_irq(client->irq, ntp070);
    kfree(ntp070); 
#ifdef CONFIG_ANDROID_POWER
    android_unregister_early_suspend(&ntp070_early_suspend);
#endif      
    this_client = NULL;
	return 0;
}

#ifdef CONFIG_ANDROID_POWER
static int ntp070_suspend(android_early_suspend_t *h)
{
	struct i2c_client *client = container_of(ntp070_device.parent, struct i2c_client, dev);
	rk28printk("Gsensor mma7760 enter suspend\n");
	return 0;
}

static int ntp070_resume(android_early_suspend_t *h)
{
	struct i2c_client *client = container_of(ntp070_device.parent, struct i2c_client, dev);
    struct ntp070_data *ntp070 = (struct ntp070_data *)i2c_get_clientdata(client);
	rk28printk("Gsensor mma7760 resume!!\n");
	return 0;
}
#else
static int ntp070_suspend(struct i2c_client *client, pm_message_t mesg)
{
	rk28printk("Gsensor mma7760 enter 2 level  suspend\n");
	return 0;
}
static int ntp070_resume(struct i2c_client *client)
{
	struct ntp070_data *ntp070 = (struct ntp070_data *)i2c_get_clientdata(client);
	rk28printk("Gsensor mma7760 2 level resume!!\n");
	return 0;
}
#endif

static const struct i2c_device_id ntp070_id[] = {
		{"ntp070", 0},
		{ }
};

static struct i2c_driver ntp070_driver = {
	.driver = {
		.name = "ntp070",
	    },
	.id_table 	= ntp070_id,
	.probe		= ntp070_probe,
	.remove		= __devexit_p(ntp070_remove),
#ifndef CONFIG_ANDROID_POWER	
	.suspend = &ntp070_suspend,
	.resume = &ntp070_resume,
#endif	
};


static int ntp070_init_client(struct i2c_client *client)
{
	struct ntp070_data *ntp070;
	int ret;
	ntp070 = i2c_get_clientdata(client);
	rk28printk("gpio_to_irq(%d) is %d\n",client->irq,gpio_to_irq(client->irq));
	if ( !gpio_is_valid(client->irq)) {
		rk28printk("+++++++++++gpio_is_invalid\n");
		return -EINVAL;
	}
	ret = gpio_request(client->irq, "ntp070_int");
	if (ret) {
		rk28printk( "failed to request mma7990_trig GPIO%d\n",gpio_to_irq(client->irq));
		return ret;
	}
    ret = gpio_direction_input(client->irq);
    if (ret) {
        rk28printk("failed to set mma7990_trig GPIO gpio input\n");
		return ret;
    }
	gpio_pull_updown(client->irq, GPIOPullUp);
	client->irq = gpio_to_irq(client->irq);
	ret = request_irq(client->irq, ntp070_interrupt, IRQF_TRIGGER_FALLING, client->dev.driver->name, ntp070);
	rk28printk("request irq is %d,ret is  0x%x\n",client->irq,ret);
	if (ret ) {
		rk28printk(KERN_ERR "ntp070_init_client: request irq failed,ret is %d\n",ret);
        return ret;
	}
	enable_irq(client->irq);
 
	return 0;
}

static int  ntp070_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct ntp070_data *ntp070;
	int err;
	

	ntp070 = kzalloc(sizeof(struct ntp070_data), GFP_KERNEL);
	if (!ntp070) {
		rk28printk("[ntp070]:alloc data failed.\n");
		err = -ENOMEM;
		goto exit_alloc_data_failed;
	}
    
#ifdef TOUCH_TP20466A
		//rk28printk("\n *** tp20466a_i2c_set_regs start *** \n");mdelay(3000);//
		err=tp20466a_i2c_set_regs(client, 0x30, tp20466a_init_data, sizeof(tp20466a_init_data)/sizeof(u8));
		//rk28printk("\n tp20466a_i2c_set_regs=%d\n",err);
		if(err<0) return err;
		//tp20466a_read_test(this_client,0x69,NULL);
#endif
	INIT_WORK(&ntp070->work, ntp070_work_func);

	ntp070->client = client;
	i2c_set_clientdata(client, ntp070);

	this_client = client;

	err = ntp070_init_client(client);
	if (err < 0) {
		rk28printk(KERN_ERR
		       "ntp070_probe: ntp070_init_client failed\n");
		goto exit_request_gpio_irq_failed;
	}
		
	ntp070->input_dev = input_allocate_device();
	if (!ntp070->input_dev) {
		err = -ENOMEM;
		rk28printk(KERN_ERR
		       "ntp070_probe: Failed to allocate input device\n");
		goto exit_input_allocate_device_failed;
	}

	input_set_abs_params(ntp070->input_dev, ABS_X,0,LCD_MAX_LENGTH-1,0, 0);
	input_set_abs_params(ntp070->input_dev, ABS_Y,0,LCD_MAX_WIDTH-1,0, 0);
#ifdef TOUCH_TP20466A
	//input_set_abs_params(ntp070->input_dev, ABS_PRESSURE,0,MAX_12BIT,0, 0);
#endif

	ntp070->input_dev->name = "ntp070";
	ntp070->input_dev->dev.parent = &client->dev;
	ntp070->input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
	ntp070->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);

	g_ts_dev = ntp070;

	err = input_register_device(ntp070->input_dev);
	if (err < 0) {
		rk28printk(KERN_ERR
		       "ntp070_probe: Unable to register input device: %s\n",
		       ntp070->input_dev->name);
		goto exit_input_register_device_failed;
	}

#ifdef CONFIG_ANDROID_POWER
    ntp070_early_suspend.suspend = ntp070_suspend;
    ntp070_early_suspend.resume = ntp070_resume;
    ntp070_early_suspend.level = 0x2;
    android_register_early_suspend(&ntp070_early_suspend);
#endif
	rk28printk(KERN_INFO "ntp070 probe ok\n");
	tp_state = TP_STATE_IDLE;
	printk("%s:%d\n",__FUNCTION__,__LINE__);
#if 0	
	ntp070_start(client, MMA7660_RATE_32);
#endif
	return 0;

exit_misc_device_register_ntp070_device_failed:
    input_unregister_device(ntp070->input_dev);
exit_input_register_device_failed:
	input_free_device(ntp070->input_dev);
exit_input_allocate_device_failed:
    free_irq(client->irq, ntp070);
exit_request_gpio_irq_failed:
	kfree(ntp070);	
exit_alloc_data_failed:
    ;
	printk("%s:%d\n",__FUNCTION__,__LINE__);
	return err;
}


static int __init ntp070_i2c_init(void)
{
	printk("%s:%d\n",__FUNCTION__,__LINE__);
	return i2c_add_driver(&ntp070_driver);
}

static void __exit ntp070_i2c_exit(void)
{
	printk("%s:%d\n",__FUNCTION__,__LINE__);
	i2c_del_driver(&ntp070_driver);
}

device_initcall(ntp070_i2c_init);//zfl    module_init        late_initcall_sync
module_exit(ntp070_i2c_exit);