drivers/input/touchscreen/vtl/vtl_ts.c - linux-imx - Git at Google

 /*
  * VTL CTP driver
  *
  * Copyright (C) 2013 VTL Corporation
  * Copyright (C) 2016 Freescale Semiconductor, Inc
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  *
  * 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/kernel.h>
 #include <linux/module.h>
 #include <linux/version.h>
 #include <linux/fs.h>
 #include <linux/proc_fs.h>
 #include <linux/uaccess.h>
 #include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/input/mt.h>
 #include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/pm_qos.h>
 #include <linux/slab.h>
 #include <linux/types.h>

 #define FORCE_SINGLE_EVENT 1

 #include "vtl_ts.h"

 #define MIN_X       0x00
 #define MIN_Y       0x00
 #define MAX_X       1023
 #define MAX_Y       767
 #define MAX_AREA    0xff
 #define MAX_FINGERS 2


 /* Global or static variables */
 struct ts_driver g_driver;

 static struct ts_info g_ts = {
 	.driver = &g_driver,
 };
 static struct ts_info *pg_ts = &g_ts;

 static struct i2c_device_id vtl_ts_id[] = {
 	{ DRIVER_NAME, 0 },
 	{ }
 };
 MODULE_DEVICE_TABLE(i2c, vtl_ts_id);


 static int vtl_ts_config(struct ts_info *ts)
 {
 	struct device *dev;

 	DEBUG();

 	dev = &ts->driver->client->dev;

 	/* ts config */
 	ts->config_info.touch_point_number = TOUCH_POINT_NUM;

 	pr_info("Configuring vtl\n");
 	ts->config_info.screen_max_x = SCREEN_MAX_X;
 	ts->config_info.screen_max_y = SCREEN_MAX_y;
 	return 0;
 }

 void vtl_ts_free_gpio(void)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	gpio_free(ts->config_info.irq_gpio_number);
 }

 void vtl_ts_hw_reset(void)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	gpio_set_value(ts->config_info.rst_gpio_number, 0);
 	mdelay(50);
 	gpio_set_value(ts->config_info.rst_gpio_number, 1);
 }

 static irqreturn_t vtl_ts_irq(int irq, void *dev)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	queue_work(ts->driver->workqueue, &ts->driver->event_work);

 	return IRQ_HANDLED;
 }

 static union ts_xy_data *vtl_read_xy_data(struct ts_info *ts)
 {
 	struct i2c_msg msgs;
 	int err;

 	DEBUG();

 	msgs.addr = ts->driver->client->addr;
 	msgs.flags = 0x01;
 	msgs.len = sizeof(ts->xy_data.buf);
 	msgs.buf = ts->xy_data.buf;

 	err = i2c_transfer(ts->driver->client->adapter, &msgs, 1);
 	if (err != 1) {
 		pr_err("___%s:i2c read err___\n", __func__);
 		return NULL;
 	}
 	return &ts->xy_data;
 }

 static void vtl_report_xy_coord(struct input_dev *input_dev,
 				union ts_xy_data *xy_data,
 				unsigned char touch_point_number)
 {
 	struct ts_info *ts;
 	int id;
 	int sync;
 	int x, y;
 	unsigned int press;
 	static unsigned int release;

 	ts = pg_ts;
 	DEBUG();

 	/* report points */
 	sync = 0;  press = 0;
 	for (id = 0; id < touch_point_number; id++) {
 		if ((xy_data->point[id].xhi != 0xFF) &&
 		    (xy_data->point[id].yhi != 0xFF) &&
 		   ((xy_data->point[id].status == 1) ||
 		    (xy_data->point[id].status == 2))) {
 			x = (xy_data->point[id].xhi<<4) |
 			    (xy_data->point[id].xlo&0xF);
 			y = (xy_data->point[id].yhi<<4) |
 			    (xy_data->point[id].ylo&0xF);

 		if (ts->config_info.exchange_x_y_flag)
 			swap(x, y);

 		if (ts->config_info.revert_x_flag)
 			x = ts->config_info.screen_max_x - x;

 		if (ts->config_info.revert_y_flag)
 			y = ts->config_info.screen_max_y - y;
 #ifndef FORCE_SINGLE_EVENT
 			input_mt_slot(input_dev, xy_data->point[id].id - 1);
 			input_mt_report_slot_state(input_dev,
 						   MT_TOOL_FINGER, true);
 			input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 			input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 			input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, 30);
 			input_report_abs(input_dev, ABS_MT_WIDTH_MAJOR, 128);
 #else
 			input_report_abs(input_dev, ABS_X, x);
 			input_report_abs(input_dev, ABS_Y, y);
 			input_report_key(input_dev, BTN_TOUCH, 1);
 			input_report_abs(input_dev, ABS_PRESSURE, 1);
 #endif
 			sync = 1;
 			press |= 0x01 << (xy_data->point[id].id - 1);
 		}
 	}

 	release &= (release ^ press); /*release point flag */
 	for (id = 0; id < touch_point_number; id++) {
 		if (release & (0x01 << id)) {
 #ifndef FORCE_SINGLE_EVENT
 			input_mt_slot(input_dev, id);
 			input_mt_report_slot_state(input_dev,
 						   MT_TOOL_FINGER, false);
 #else
 			input_report_key(input_dev, BTN_TOUCH, 0);
 			input_report_abs(input_dev, ABS_PRESSURE, 0);
 #endif
 			sync = 1;
 		}

 	}
 	release = press;

 	if (sync)
 		input_sync(input_dev);
 }

 static void vtl_ts_workfunc(struct work_struct *work)
 {

 	union ts_xy_data *xy_data;
 	struct input_dev *input_dev;
 	unsigned char touch_point_number;

 	DEBUG();

 	input_dev = pg_ts->driver->input_dev;
 	touch_point_number = pg_ts->config_info.touch_point_number;

 	xy_data = vtl_read_xy_data(pg_ts);
 	if (xy_data != NULL)
 		vtl_report_xy_coord(input_dev, xy_data, touch_point_number);
 	else
 		pr_err("____xy_data error___\n");
 }

 #ifdef CONFIG_PM_SLEEP
 int vtl_ts_suspend(struct device *dev)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	disable_irq(ts->config_info.irq_number);
 	cancel_work_sync(&ts->driver->event_work);

 	return 0;
 }

 int vtl_ts_resume(struct device *dev)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	/* Hardware reset */
 	vtl_ts_hw_reset();
 	enable_irq(ts->config_info.irq_number);

 	return 0;
 }
 #endif

 #ifdef CONFIG_HAS_EARLYSUSPEND
 static void vtl_ts_early_suspend(struct early_suspend *handler)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	vtl_ts_suspend(ts->driver->client, PMSG_SUSPEND);
 }

 static void vtl_ts_early_resume(struct early_suspend *handler)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	vtl_ts_resume(ts->driver->client);
 }
 #endif

 int  vtl_ts_remove(struct i2c_client *client)
 {
 	struct ts_info *ts;

 	ts = pg_ts;
 	DEBUG();

 	/* Driver clean up */

 	free_irq(ts->config_info.irq_number, ts);
 	vtl_ts_free_gpio();

 #ifdef CONFIG_HAS_EARLYSUSPEND
 	unregister_early_suspend(&ts->driver->early_suspend);
 #endif

 	cancel_work_sync(&ts->driver->event_work);
 	destroy_workqueue(ts->driver->workqueue);

 	input_unregister_device(ts->driver->input_dev);
 	input_free_device(ts->driver->input_dev);

 	if (ts->driver->proc_entry != NULL)
 		remove_proc_entry(DRIVER_NAME, NULL);

 	return 0;
 }

 static int init_input_dev(struct ts_info *ts)
 {
 	struct input_dev *input_dev;
 	struct device *dev;
 	int err;

 	DEBUG();

 	dev = &ts->driver->client->dev;

 	/* allocate input device */
 	ts->driver->input_dev = devm_input_allocate_device(dev);
 	if (ts->driver->input_dev == NULL) {
 		dev_err(dev, "Unable to allocate input device for device %s\n",
 			DRIVER_NAME);
 		return -1;
 	}

 	input_dev = ts->driver->input_dev;

 	input_dev->name = "VTL for wld";
 	input_dev->phys = "I2C";
 	input_dev->id.bustype = BUS_I2C;
 	input_dev->id.vendor  = 0xaaaa;
 	input_dev->id.product = 0x5555;
 	input_dev->id.version = 0x0001;
 	input_dev->dev.parent = dev;

 	/* config input device */
 	__set_bit(EV_SYN, input_dev->evbit);
 	__set_bit(EV_KEY, input_dev->evbit);
 	__set_bit(EV_ABS, input_dev->evbit);

 #ifdef FORCE_SINGLE_EVENT
 	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 	input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1, 0, 0);
 	input_set_abs_params(input_dev, ABS_X, MIN_X, MAX_X, 0, 0);
 	input_set_abs_params(input_dev, ABS_Y, MIN_Y, MAX_Y, 0, 0);
 #else
 	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);

 	input_mt_init_slots(input_dev, TOUCH_POINT_NUM, 0);
 	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
 			     ts->config_info.screen_max_x, 0, 0);
 	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
 			     ts->config_info.screen_max_y, 0, 0);
 	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 	input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 #endif
 	/* register input device */
 	err = input_register_device(input_dev);
 	if (err) {
 		dev_err(dev, "Unable to register input device for device %s\n",
 			DRIVER_NAME);
 		return -1;
 	}

 	return 0;
 }

 int ct36x_test_tp(struct i2c_client *client)
 {
 	struct i2c_msg msgs;
 	char buf;

 	msgs.addr = 0x7F;
 	msgs.flags = 0x01;
 	msgs.len = 1;
 	msgs.buf = &buf;

 	if (i2c_transfer(client->adapter, &msgs, 1) != 1)
 		return -1;

 	return 0;
 }

 int vtl_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
 	int err = -1;
 	struct ts_info *ts;
 	struct device *dev;

 	ts = pg_ts;
 	ts->driver->client = client;
 	dev = &ts->driver->client->dev;

 	/*Probing TouchScreen*/
 	pr_info("Probing vtl touchscreen, touchscreen node found\n");
 	if (ct36x_test_tp(client) < 0) {
 			pr_err("vtl tp not found\n");
 			goto ERR_TS_CONFIG;
 	}

 	/* Request platform resources (gpio/interrupt pins) */
 	err = vtl_ts_config(ts);
 	if (err) {
 		dev_err(dev, "VTL touch screen config Failed.\n");
 		goto ERR_TS_CONFIG;
 	}

 	/*Requestion GPIO*/
 	ts->config_info.rst_gpio_number = of_get_gpio(client->dev.of_node, 0);
 	if (gpio_is_valid(ts->config_info.rst_gpio_number)) {
 		err = devm_gpio_request(dev,
 					ts->config_info.rst_gpio_number, NULL);
 		if (err) {
 			dev_err(dev, "Unable to request GPIO %d\n",
 				ts->config_info.rst_gpio_number);
 			return err;
 		}
 	}

 	/* Check I2C Functionality */
 	err = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
 	if (!err) {
 		dev_err(dev, "Check I2C Functionality Failed.\n");
 		return -ENODEV;
 	}

 	err = devm_request_threaded_irq(dev, client->irq,
 					NULL, vtl_ts_irq,
 					IRQF_ONESHOT,
 					client->name, ts);
 	if (err) {
 		dev_err(&client->dev, "VTL Failed to register interrupt\n");

 		goto ERR_IRQ_REQ;
 	}

 	vtl_ts_hw_reset();

 	/*init input dev*/
 	err = init_input_dev(ts);
 	if (err) {

 		dev_err(dev, "init input dev failed.\n");
 		goto ERR_INIT_INPUT;
 	}

 	/* register early suspend */
 #ifdef CONFIG_HAS_EARLYSUSPEND
 	ts->driver->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
 	ts->driver->early_suspend.suspend = vtl_ts_early_suspend;
 	ts->driver->early_suspend.resume = vtl_ts_early_resume;
 	register_early_suspend(&ts->driver->early_suspend);
 #endif
 	/* Create work queue */
 	INIT_WORK(&ts->driver->event_work, vtl_ts_workfunc);
 	ts->driver->workqueue = create_singlethread_workqueue(DRIVER_NAME);

 	return 0;

 ERR_IRQ_REQ:
 	cancel_work_sync(&ts->driver->event_work);
 	destroy_workqueue(ts->driver->workqueue);

 ERR_INIT_INPUT:
 	input_free_device(ts->driver->input_dev);
 	gpio_free(ts->config_info.rst_gpio_number);
 ERR_TS_CONFIG:

 	return err;
 }


 static SIMPLE_DEV_PM_OPS(vtl_ts_pm_ops, vtl_ts_suspend, vtl_ts_resume);

 static const struct of_device_id vtl_ts_dt_ids[] = {
 	{ .compatible = "vtl,ct365", },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, vtl_ts_dt_ids);


 static struct i2c_driver vtl_ts_driver  = {
 	.probe      = vtl_ts_probe,
 	.remove     = vtl_ts_remove,
 	.id_table   = vtl_ts_id,
 	.driver = {
 		.owner  = THIS_MODULE,
 		.name   = DRIVER_NAME,
 		.pm     = &vtl_ts_pm_ops,
 		.of_match_table = of_match_ptr(vtl_ts_dt_ids),
 	},
 };

 module_i2c_driver(vtl_ts_driver);

 MODULE_AUTHOR("VTL");
 MODULE_DESCRIPTION("VTL TouchScreen driver");
 MODULE_LICENSE("GPL");
	/*
	* VTL CTP driver
	*
	* Copyright (C) 2013 VTL Corporation
	* Copyright (C) 2016 Freescale Semiconductor, Inc
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* version 2 as published by the Free Software Foundation.
	*
	* 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/kernel.h>
	#include <linux/module.h>
	#include <linux/version.h>
	#include <linux/fs.h>
	#include <linux/proc_fs.h>
	#include <linux/uaccess.h>
	#include <linux/i2c.h>
	#include <linux/delay.h>
	#include <linux/interrupt.h>
	#include <linux/input.h>
	#include <linux/input/mt.h>
	#include <linux/gpio.h>
	#include <linux/of.h>
	#include <linux/of_gpio.h>
	#include <linux/pm_qos.h>
	#include <linux/slab.h>
	#include <linux/types.h>

	#define FORCE_SINGLE_EVENT 1

	#include "vtl_ts.h"

	#define MIN_X 0x00
	#define MIN_Y 0x00
	#define MAX_X 1023
	#define MAX_Y 767
	#define MAX_AREA 0xff
	#define MAX_FINGERS 2


	/* Global or static variables */
	struct ts_driver g_driver;

	static struct ts_info g_ts = {
	.driver = &g_driver,
	};
	static struct ts_info *pg_ts = &g_ts;

	static struct i2c_device_id vtl_ts_id[] = {
	{ DRIVER_NAME, 0 },
	{ }
	};
	MODULE_DEVICE_TABLE(i2c, vtl_ts_id);


	static int vtl_ts_config(struct ts_info *ts)
	{
	struct device *dev;

	DEBUG();

	dev = &ts->driver->client->dev;

	/* ts config */
	ts->config_info.touch_point_number = TOUCH_POINT_NUM;

	pr_info("Configuring vtl\n");
	ts->config_info.screen_max_x = SCREEN_MAX_X;
	ts->config_info.screen_max_y = SCREEN_MAX_y;
	return 0;
	}

	void vtl_ts_free_gpio(void)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	gpio_free(ts->config_info.irq_gpio_number);
	}

	void vtl_ts_hw_reset(void)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	gpio_set_value(ts->config_info.rst_gpio_number, 0);
	mdelay(50);
	gpio_set_value(ts->config_info.rst_gpio_number, 1);
	}

	static irqreturn_t vtl_ts_irq(int irq, void *dev)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	queue_work(ts->driver->workqueue, &ts->driver->event_work);

	return IRQ_HANDLED;
	}

	static union ts_xy_data vtl_read_xy_data(struct ts_info ts)
	{
	struct i2c_msg msgs;
	int err;

	DEBUG();

	msgs.addr = ts->driver->client->addr;
	msgs.flags = 0x01;
	msgs.len = sizeof(ts->xy_data.buf);
	msgs.buf = ts->xy_data.buf;

	err = i2c_transfer(ts->driver->client->adapter, &msgs, 1);
	if (err != 1) {
	pr_err("___%s:i2c read err___\n", __func__);
	return NULL;
	}
	return &ts->xy_data;
	}

	static void vtl_report_xy_coord(struct input_dev *input_dev,
	union ts_xy_data *xy_data,
	unsigned char touch_point_number)
	{
	struct ts_info *ts;
	int id;
	int sync;
	int x, y;
	unsigned int press;
	static unsigned int release;

	ts = pg_ts;
	DEBUG();

	/* report points */
	sync = 0; press = 0;
	for (id = 0; id < touch_point_number; id++) {
	if ((xy_data->point[id].xhi != 0xFF) &&
	(xy_data->point[id].yhi != 0xFF) &&
	((xy_data->point[id].status == 1) \|\|
	(xy_data->point[id].status == 2))) {
	x = (xy_data->point[id].xhi<<4) \|
	(xy_data->point[id].xlo&0xF);
	y = (xy_data->point[id].yhi<<4) \|
	(xy_data->point[id].ylo&0xF);

	if (ts->config_info.exchange_x_y_flag)
	swap(x, y);

	if (ts->config_info.revert_x_flag)
	x = ts->config_info.screen_max_x - x;

	if (ts->config_info.revert_y_flag)
	y = ts->config_info.screen_max_y - y;
	#ifndef FORCE_SINGLE_EVENT
	input_mt_slot(input_dev, xy_data->point[id].id - 1);
	input_mt_report_slot_state(input_dev,
	MT_TOOL_FINGER, true);
	input_report_abs(input_dev, ABS_MT_POSITION_X, x);
	input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
	input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, 30);
	input_report_abs(input_dev, ABS_MT_WIDTH_MAJOR, 128);
	#else
	input_report_abs(input_dev, ABS_X, x);
	input_report_abs(input_dev, ABS_Y, y);
	input_report_key(input_dev, BTN_TOUCH, 1);
	input_report_abs(input_dev, ABS_PRESSURE, 1);
	#endif
	sync = 1;
	press \|= 0x01 << (xy_data->point[id].id - 1);
	}
	}

	release &= (release ^ press); /release point flag /
	for (id = 0; id < touch_point_number; id++) {
	if (release & (0x01 << id)) {
	#ifndef FORCE_SINGLE_EVENT
	input_mt_slot(input_dev, id);
	input_mt_report_slot_state(input_dev,
	MT_TOOL_FINGER, false);
	#else
	input_report_key(input_dev, BTN_TOUCH, 0);
	input_report_abs(input_dev, ABS_PRESSURE, 0);
	#endif
	sync = 1;
	}

	}
	release = press;

	if (sync)
	input_sync(input_dev);
	}

	static void vtl_ts_workfunc(struct work_struct *work)
	{

	union ts_xy_data *xy_data;
	struct input_dev *input_dev;
	unsigned char touch_point_number;

	DEBUG();

	input_dev = pg_ts->driver->input_dev;
	touch_point_number = pg_ts->config_info.touch_point_number;

	xy_data = vtl_read_xy_data(pg_ts);
	if (xy_data != NULL)
	vtl_report_xy_coord(input_dev, xy_data, touch_point_number);
	else
	pr_err("____xy_data error___\n");
	}

	#ifdef CONFIG_PM_SLEEP
	int vtl_ts_suspend(struct device *dev)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	disable_irq(ts->config_info.irq_number);
	cancel_work_sync(&ts->driver->event_work);

	return 0;
	}

	int vtl_ts_resume(struct device *dev)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	/* Hardware reset */
	vtl_ts_hw_reset();
	enable_irq(ts->config_info.irq_number);

	return 0;
	}
	#endif

	#ifdef CONFIG_HAS_EARLYSUSPEND
	static void vtl_ts_early_suspend(struct early_suspend *handler)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	vtl_ts_suspend(ts->driver->client, PMSG_SUSPEND);
	}

	static void vtl_ts_early_resume(struct early_suspend *handler)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	vtl_ts_resume(ts->driver->client);
	}
	#endif

	int vtl_ts_remove(struct i2c_client *client)
	{
	struct ts_info *ts;

	ts = pg_ts;
	DEBUG();

	/* Driver clean up */

	free_irq(ts->config_info.irq_number, ts);
	vtl_ts_free_gpio();

	#ifdef CONFIG_HAS_EARLYSUSPEND
	unregister_early_suspend(&ts->driver->early_suspend);
	#endif

	cancel_work_sync(&ts->driver->event_work);
	destroy_workqueue(ts->driver->workqueue);

	input_unregister_device(ts->driver->input_dev);
	input_free_device(ts->driver->input_dev);

	if (ts->driver->proc_entry != NULL)
	remove_proc_entry(DRIVER_NAME, NULL);

	return 0;
	}

	static int init_input_dev(struct ts_info *ts)
	{
	struct input_dev *input_dev;
	struct device *dev;
	int err;

	DEBUG();

	dev = &ts->driver->client->dev;

	/* allocate input device */
	ts->driver->input_dev = devm_input_allocate_device(dev);
	if (ts->driver->input_dev == NULL) {
	dev_err(dev, "Unable to allocate input device for device %s\n",
	DRIVER_NAME);
	return -1;
	}

	input_dev = ts->driver->input_dev;

	input_dev->name = "VTL for wld";
	input_dev->phys = "I2C";
	input_dev->id.bustype = BUS_I2C;
	input_dev->id.vendor = 0xaaaa;
	input_dev->id.product = 0x5555;
	input_dev->id.version = 0x0001;
	input_dev->dev.parent = dev;

	/* config input device */
	__set_bit(EV_SYN, input_dev->evbit);
	__set_bit(EV_KEY, input_dev->evbit);
	__set_bit(EV_ABS, input_dev->evbit);

	#ifdef FORCE_SINGLE_EVENT
	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
	input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1, 0, 0);
	input_set_abs_params(input_dev, ABS_X, MIN_X, MAX_X, 0, 0);
	input_set_abs_params(input_dev, ABS_Y, MIN_Y, MAX_Y, 0, 0);
	#else
	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);

	input_mt_init_slots(input_dev, TOUCH_POINT_NUM, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
	ts->config_info.screen_max_x, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
	ts->config_info.screen_max_y, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
	#endif
	/* register input device */
	err = input_register_device(input_dev);
	if (err) {
	dev_err(dev, "Unable to register input device for device %s\n",
	DRIVER_NAME);
	return -1;
	}

	return 0;
	}

	int ct36x_test_tp(struct i2c_client *client)
	{
	struct i2c_msg msgs;
	char buf;

	msgs.addr = 0x7F;
	msgs.flags = 0x01;
	msgs.len = 1;
	msgs.buf = &buf;

	if (i2c_transfer(client->adapter, &msgs, 1) != 1)
	return -1;

	return 0;
	}

	int vtl_ts_probe(struct i2c_client client, const struct i2c_device_id id)
	{
	int err = -1;
	struct ts_info *ts;
	struct device *dev;

	ts = pg_ts;
	ts->driver->client = client;
	dev = &ts->driver->client->dev;

	/Probing TouchScreen/
	pr_info("Probing vtl touchscreen, touchscreen node found\n");
	if (ct36x_test_tp(client) < 0) {
	pr_err("vtl tp not found\n");
	goto ERR_TS_CONFIG;
	}

	/* Request platform resources (gpio/interrupt pins) */
	err = vtl_ts_config(ts);
	if (err) {
	dev_err(dev, "VTL touch screen config Failed.\n");
	goto ERR_TS_CONFIG;
	}

	/Requestion GPIO/
	ts->config_info.rst_gpio_number = of_get_gpio(client->dev.of_node, 0);
	if (gpio_is_valid(ts->config_info.rst_gpio_number)) {
	err = devm_gpio_request(dev,
	ts->config_info.rst_gpio_number, NULL);
	if (err) {
	dev_err(dev, "Unable to request GPIO %d\n",
	ts->config_info.rst_gpio_number);
	return err;
	}
	}

	/* Check I2C Functionality */
	err = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
	if (!err) {
	dev_err(dev, "Check I2C Functionality Failed.\n");
	return -ENODEV;
	}

	err = devm_request_threaded_irq(dev, client->irq,
	NULL, vtl_ts_irq,
	IRQF_ONESHOT,
	client->name, ts);
	if (err) {
	dev_err(&client->dev, "VTL Failed to register interrupt\n");

	goto ERR_IRQ_REQ;
	}

	vtl_ts_hw_reset();

	/init input dev/
	err = init_input_dev(ts);
	if (err) {

	dev_err(dev, "init input dev failed.\n");
	goto ERR_INIT_INPUT;
	}

	/* register early suspend */
	#ifdef CONFIG_HAS_EARLYSUSPEND
	ts->driver->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	ts->driver->early_suspend.suspend = vtl_ts_early_suspend;
	ts->driver->early_suspend.resume = vtl_ts_early_resume;
	register_early_suspend(&ts->driver->early_suspend);
	#endif
	/* Create work queue */
	INIT_WORK(&ts->driver->event_work, vtl_ts_workfunc);
	ts->driver->workqueue = create_singlethread_workqueue(DRIVER_NAME);

	return 0;

	ERR_IRQ_REQ:
	cancel_work_sync(&ts->driver->event_work);
	destroy_workqueue(ts->driver->workqueue);

	ERR_INIT_INPUT:
	input_free_device(ts->driver->input_dev);
	gpio_free(ts->config_info.rst_gpio_number);
	ERR_TS_CONFIG:

	return err;
	}


	static SIMPLE_DEV_PM_OPS(vtl_ts_pm_ops, vtl_ts_suspend, vtl_ts_resume);

	static const struct of_device_id vtl_ts_dt_ids[] = {
	{ .compatible = "vtl,ct365", },
	{ }
	};
	MODULE_DEVICE_TABLE(of, vtl_ts_dt_ids);


	static struct i2c_driver vtl_ts_driver = {
	.probe = vtl_ts_probe,
	.remove = vtl_ts_remove,
	.id_table = vtl_ts_id,
	.driver = {
	.owner = THIS_MODULE,
	.name = DRIVER_NAME,
	.pm = &vtl_ts_pm_ops,
	.of_match_table = of_match_ptr(vtl_ts_dt_ids),
	},
	};

	module_i2c_driver(vtl_ts_driver);

	MODULE_AUTHOR("VTL");
	MODULE_DESCRIPTION("VTL TouchScreen driver");
	MODULE_LICENSE("GPL");