summaryrefslogtreecommitdiff
path: root/drivers/input/touchscreen/ft5x0x_ts_v1.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/input/touchscreen/ft5x0x_ts_v1.c')
-rw-r--r--drivers/input/touchscreen/ft5x0x_ts_v1.c1691
1 files changed, 1691 insertions, 0 deletions
diff --git a/drivers/input/touchscreen/ft5x0x_ts_v1.c b/drivers/input/touchscreen/ft5x0x_ts_v1.c
new file mode 100644
index 00000000..135b79d2
--- /dev/null
+++ b/drivers/input/touchscreen/ft5x0x_ts_v1.c
@@ -0,0 +1,1691 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications 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.
+ */
+
+
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <asm/uaccess.h>
+#include <linux/gpio.h>
+#include <linux/earlysuspend.h>
+#include <linux/regulator/consumer.h>
+#include <linux/i2c/ft5x0x_ts.h>
+#include <mach/regulator.h>
+
+#include <mach/hardware.h>
+#include<mach/globalregs.h>
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/fb.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+/*********************************Bee-0928-TOP****************************************/
+
+static unsigned char debug_level=PIXCIR_DEBUG;
+
+#define CONFIG_FT5X0X_MULTITOUCH
+
+#define PIXCIR_DBG(format, ...) \
+ if(debug_level == 1) \
+ printk(KERN_INFO "PIXCIR " format "\n", ## __VA_ARGS__)
+
+static struct i2c_client *this_client;
+static struct ft5x0x_ts_struct *g_ft5x0x_ts;
+static unsigned char status_reg = 0;
+static struct point_node_t point_slot[MAX_FINGER_NUM*2];
+static struct point_node_t point_slot_back[MAX_FINGER_NUM*2];
+static int distance[5]={0};
+static int touch_flage[5]={0};
+static struct i2c_driver ft5x0x_i2c_ts_driver;
+static struct class *i2c_dev_class;
+static LIST_HEAD( i2c_dev_list);
+static DEFINE_SPINLOCK( i2c_dev_list_lock);
+
+
+static ssize_t ft5x0x_set_calibrate(struct device* cd, struct device_attribute *attr,const char* buf, size_t len);
+static ssize_t ft5x0x_show_suspend(struct device* cd,struct device_attribute *attr, char* buf);
+static ssize_t ft5x0x_store_suspend(struct device* cd, struct device_attribute *attr,const char* buf, size_t len);
+
+
+static int ft5x0x_read_data(struct ft5x0x_ts_struct *data);
+static void ft5x0x_report_value(struct ft5x0x_ts_struct *data);
+
+static void ft5x0x_reset(int reset_pin);
+static void ft5x0x_ts_suspend(struct early_suspend *handler);
+static void ft5x0x_ts_resume(struct early_suspend *handler);
+static void ft5x0x_ts_pwron(struct regulator *reg_vdd);
+static void ft5x0x_ts_pwroff(struct regulator *reg_vdd);
+static int ft5x0x_tx_config(void);
+//static DEVICE_ATTR(calibrate, S_IRUGO | S_IWUSR, NULL, pixcir_set_calibrate);
+//static DEVICE_ATTR(suspend, S_IRUGO | S_IWUSR, pixcir_show_suspend, pixcir_store_suspend);
+//static DEVICE_ATTR(debug, S_IRUGO | S_IWUSR, pixcir_show_debug, pixcir_store_debug);
+
+#define FTS_FW_DOWNLOAD
+#ifdef FTS_FW_DOWNLOAD
+#define FTS_PACKET_LENGTH 128
+#define FT5x0x_TX_NUM 28
+#define FT5x0x_RX_NUM 16
+static unsigned char CTPM_FW[]=
+{
+ #include "ft5x0x_fw_0x16.dat"
+};
+#endif
+
+
+/* pixcir_i2c_rxdata -- read data from i2c
+ * @rxdata: read buffer, first output variable
+ * @length: read length, second input variable
+ * @return: eror value, 0 means successful
+ */
+static int ft5x0x_i2c_rxdata(char *rxdata, int length)
+{
+ int ret;
+ struct i2c_msg msgs[] = {
+ {
+ .addr = g_ft5x0x_ts->client->addr,
+ .flags = 0,
+ .len = 1,
+ .buf = rxdata,
+ },
+ {
+ .addr = g_ft5x0x_ts->client->addr,
+ .flags = I2C_M_RD,
+ .len = length,
+ .buf = rxdata,
+ },
+ };
+
+ ret = i2c_transfer(g_ft5x0x_ts->client->adapter, msgs,2);
+ if (ret < 0)
+ pr_err("%s i2c read error: %d\n", __func__, ret);
+
+ return ret;
+}
+
+/* pixcir_i2c_txdata -- write data to i2c
+ * @rxdata: write buffer, first input variable
+ * @length: length length, second input variable
+ * @return: eror value, 0 means successful
+ */
+static int ft5x0x_i2c_txdata(char *txdata, int length)
+{
+ int ret;
+ struct i2c_msg msg[] = {
+ {
+ .addr = g_ft5x0x_ts->client->addr,
+ .flags = 0,
+ .len = length,
+ .buf = txdata,
+ },
+ };
+
+ ret = i2c_transfer(g_ft5x0x_ts->client->adapter, msg, 1);
+ if (ret < 0)
+ pr_err("%s i2c write error: %d\n", __func__, ret);
+
+ return ret;
+}
+
+
+/* pixcir_i2c_write_data -- write one byte to i2c
+ * @rxdata: the register address of the i2c device , first input variable
+ * @length: the data to write , second input variable
+ * @return: eror value, 0 means successful
+ */
+static int ft5x0x_i2c_write_data(unsigned char addr, unsigned char data)
+{
+ unsigned char buf[2];
+ buf[0]=addr;
+ buf[1]=data;
+ return ft5x0x_i2c_txdata(buf, 2);
+}
+
+static DEVICE_ATTR(calibrate, S_IRUGO | S_IWUSR, NULL, ft5x0x_set_calibrate);
+static DEVICE_ATTR(suspend, S_IRUGO | S_IWUSR, ft5x0x_show_suspend, ft5x0x_store_suspend);
+
+static ssize_t ft5x0x_set_calibrate(struct device* cd, struct device_attribute *attr,
+ const char* buf, size_t len)
+{
+ unsigned long on_off = simple_strtoul(buf, NULL, 10);
+
+ if(on_off==1)
+ {
+ PIXCIR_DBG("%s: PIXCIR calibrate\n",__func__);
+ ft5x0x_i2c_write_data(0x3a , 0x03);
+ msleep(5*1000);
+ }
+
+ return len;
+}
+
+
+/* pixcir_show_suspend -- for suspend/resume debug
+ * show current status
+ * params: no care
+ * @return: len
+ */
+static ssize_t ft5x0x_show_suspend(struct device* cd,
+ struct device_attribute *attr, char* buf)
+{
+ ssize_t ret = 0;
+
+ if(g_ft5x0x_ts->suspend_flag==1)
+ sprintf(buf, "Pixcir Suspend\n");
+ else
+ sprintf(buf, "Pixcir Resume\n");
+
+ ret = strlen(buf) + 1;
+
+ return ret;
+}
+
+
+/* pixcir_store_suspend -- for suspend/resume debug
+ * set suspend/resume
+ * params: no care
+ * @return: len
+ */
+static ssize_t ft5x0x_store_suspend(struct device* cd, struct device_attribute *attr,
+ const char* buf, size_t len)
+{
+ unsigned long on_off = simple_strtoul(buf, NULL, 10);
+ g_ft5x0x_ts->suspend_flag= on_off;
+
+ if(on_off==1)
+ {
+ PIXCIR_DBG(KERN_INFO "Pixcir Entry Suspend\n");
+ ft5x0x_ts_suspend(NULL);
+ }
+ else
+ {
+ PIXCIR_DBG(KERN_INFO "Pixcir Entry Resume\n");
+ ft5x0x_ts_resume(NULL);
+ }
+
+ return len;
+}
+
+
+/* pixcir_create_sysfs -- create sysfs attribute
+ * client: i2c client
+ * @return: len
+ */
+static int ft5x0x_create_sysfs(struct i2c_client *client)
+{
+ int err;
+ struct device *dev = &(client->dev);
+
+ PIXCIR_DBG("%s", __func__);
+
+ err = device_create_file(dev, &dev_attr_calibrate);
+ err = device_create_file(dev, &dev_attr_suspend);
+
+ return err;
+}
+
+/* pixcir_ts_sleep -- set pixicir into sleep mode
+ * @return: none
+ */
+static void ft5x0x_ts_sleep(void)
+{
+ PIXCIR_DBG(KERN_INFO "==%s==\n", __func__);
+ //pixcir_i2c_write_data(PIXCIR_PWR_MODE_REG , PIXCIR_PWR_SLEEP_MODE);
+}
+
+/* pixcir_ts_suspend -- set pixicr into suspend
+ * @return: none
+ */
+static void ft5x0x_ts_suspend(struct early_suspend *handler)
+{
+ disable_irq_nosync(g_ft5x0x_ts->ft5x0x_irq);
+ ft5x0x_ts_pwroff(g_ft5x0x_ts->reg_vdd);
+}
+
+/* pixcir_ts_resume -- set pixicr to resume
+ * @return: none
+ */
+static void ft5x0x_ts_resume(struct early_suspend *handler)
+{
+ ft5x0x_ts_pwron(g_ft5x0x_ts->reg_vdd);
+ gpio_direction_input(g_ft5x0x_ts->platform_data->irq_gpio_number);
+ ft5x0x_reset(g_ft5x0x_ts->platform_data->reset_gpio_number);
+ msleep(100);
+ //pixcir_tx_config();
+ enable_irq(g_ft5x0x_ts->ft5x0x_irq);
+}
+
+
+#ifdef TOUCH_VIRTUAL_KEYS
+#define SC8810_KEY_HOME 102
+#define SC8810_KEY_MENU 30
+#define SC8810_KEY_BACK 17
+#define SC8810_KEY_SEARCH 217
+
+static ssize_t virtual_keys_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ return sprintf(buf,
+ __stringify(EV_KEY) ":" __stringify(KEY_HOME) ":120:500:50:100"
+ ":" __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":40:500:50:100"
+ ":" __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":200:500:50:100"
+ ":" __stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":280:500:50:100"
+ "\n");
+}
+
+static struct kobj_attribute virtual_keys_attr = {
+ .attr = {
+ .name = "virtualkeys.ft5x0x_ts",
+ .mode = S_IRUGO,
+ },
+ .show = &virtual_keys_show,
+};
+
+static struct attribute *properties_attrs[] = {
+ &virtual_keys_attr.attr,
+ NULL
+};
+
+static struct attribute_group properties_attr_group = {
+ .attrs = properties_attrs,
+};
+
+
+/* pixcir_ts_virtual_keys_init -- register virutal keys to system
+ * @return: none
+ */
+static void ft5x0x_ts_virtual_keys_init(void)
+{
+ int ret;
+ struct kobject *properties_kobj;
+
+ PIXCIR_DBG("%s\n",__func__);
+
+ properties_kobj = kobject_create_and_add("board_properties", NULL);
+ if (properties_kobj)
+ ret = sysfs_create_group(properties_kobj,
+ &properties_attr_group);
+ if (!properties_kobj || ret)
+ pr_err("failed to create board_properties\n");
+}
+
+
+#endif
+
+
+/* pxicir_ts_pininit -- gpio request
+ * irq_pin: irq gpio number
+ * rst_pin: reset gpio number
+ * @return: none
+ */
+static void pxicir_ts_pininit(int irq_pin, int rst_pin)
+{
+ gpio_request(irq_pin, TS_IRQ_PIN);
+ gpio_request(rst_pin, TS_RESET_PIN);
+ gpio_direction_input(irq_pin);
+}
+
+/* pixcir_ts_pwron -- power on pixcir chip
+ * reg_vdd: regulator
+ * @return: none
+ */
+struct regulator *tsp_regulator_33 = NULL;
+static void ft5x0x_ts_pwroff(struct regulator *reg_vdd)
+{
+ PIXCIR_DBG(KERN_INFO "%s\n",__func__);
+ regulator_disable(tsp_regulator_33);
+ msleep(20);
+}
+static void ft5x0x_ts_pwron(struct regulator *reg_vdd)
+{
+ int err = 0;
+ PIXCIR_DBG(KERN_INFO "%s\n",__func__);
+ tsp_regulator_33 = regulator_get(NULL, REGU_NAME_TP);
+ if (IS_ERR(tsp_regulator_33)) {
+ pr_err("zinitix:could not get 3.3v regulator\n");
+ return;
+ }
+ err =regulator_set_voltage(tsp_regulator_33,3000000,3000000);
+ if (err)
+ pr_err("zinitix:could not set to 3300mv.\n");
+ //regulator_set_voltage(reg_vdd, 3000000, 3000000);
+ regulator_enable(tsp_regulator_33);
+ //__raw_writel(((__raw_readl(0x82000628) &0xfffff0ff)|(0x00000900)), 0x82000628);
+
+ msleep(20);
+}
+
+/* attb_read_val -- read the interrupt pin level
+ * gpio_pin: pin number
+ * @return: 1 or 0
+ */
+static int attb_read_val(int gpio_pin)
+{
+ return gpio_get_value(gpio_pin);
+}
+
+/* pixcir_reset -- set pixcir reset
+ * reset_pin: pin number
+ * @return: none
+ */
+static void ft5x0x_reset(int reset_pin)
+{
+ PIXCIR_DBG(KERN_INFO "%s\n",__func__);
+ #if 0
+ gpio_direction_output(reset_pin, 0);
+ msleep(3);
+ gpio_set_value(reset_pin, 1);
+ msleep(10);
+ gpio_set_value(reset_pin,0);
+ msleep(10);
+ #endif
+}
+
+/* pixcir_tx_config -- initialize the pixcir register
+ * @return: error code
+ */
+static int ft5x0x_tx_config(void)
+{
+ int error;
+ unsigned char buf;
+#if 0
+ error=pixcir_i2c_write_data(PIXCIR_INT_MODE_REG, PIXCIR_INT_MODE);
+ buf = PIXCIR_INT_MODE_REG;
+ error=pixcir_i2c_rxdata(&buf, 1);
+ PIXCIR_DBG("%s: buf=0x%x",__func__, buf);
+ return error;
+#endif
+ return 0;
+}
+
+
+static void return_i2c_dev(struct i2c_dev *i2c_dev)
+{
+ spin_lock(&i2c_dev_list_lock);
+ list_del(&i2c_dev->list);
+ spin_unlock(&i2c_dev_list_lock);
+ kfree(i2c_dev);
+}
+
+static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
+{
+ struct i2c_dev *i2c_dev;
+ i2c_dev = NULL;
+
+ spin_lock(&i2c_dev_list_lock);
+ list_for_each_entry(i2c_dev, &i2c_dev_list, list)
+ {
+ if (i2c_dev->adap->nr == index)
+ goto found;
+ }
+ i2c_dev = NULL;
+ found: spin_unlock(&i2c_dev_list_lock);
+ return i2c_dev;
+}
+
+static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
+{
+ struct i2c_dev *i2c_dev;
+
+ if (adap->nr >= I2C_MINORS) {
+ printk(KERN_ERR "%s: i2c-dev: Out of device minors\n",__func__);
+ return ERR_PTR(-ENODEV);
+ }
+
+ i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
+ if (!i2c_dev)
+ return ERR_PTR(-ENOMEM);
+
+ i2c_dev->adap = adap;
+
+ spin_lock(&i2c_dev_list_lock);
+ list_add_tail(&i2c_dev->list, &i2c_dev_list);
+ spin_unlock(&i2c_dev_list_lock);
+ return i2c_dev;
+}
+/*********************************Bee-0928-bottom**************************************/
+
+
+/* pixcir_ts_poscheck -- check it finger on TP and it's position,
+ * report event to input system
+ * pixcir_ts_struct: pixicir data struct
+ * @return: none
+ */
+static void ft5x0x_ts_poscheck(struct ft5x0x_ts_struct *data)
+{
+ int ret = 0;
+ struct ft5x0x_ts_struct *tsdata = data;
+ PIXCIR_DBG("%s\n", __func__);
+ ret = ft5x0x_read_data(tsdata);
+ if (ret == 0) {
+ ft5x0x_report_value(tsdata);
+ }
+}
+static void ft5x0x_ts_release(struct ft5x0x_ts_struct *data)
+{
+#ifdef CONFIG_FT5X0X_MULTITOUCH
+ input_report_key(data->input, BTN_TOUCH, 0);
+ input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, 0);
+#else
+ input_report_abs(data->input, ABS_PRESSURE, 0);
+ input_report_key(data->input, BTN_TOUCH, 0);
+#endif
+ input_sync(data->input);
+}
+static int ft5x0x_read_data(struct ft5x0x_ts_struct *data)
+{
+ struct ts_event *event = &data->event;
+ u8 buf[32] = {0};
+ int ret = -1;
+ int touch_point = 0;
+
+ /*printk("==read data=\n"); */
+#ifdef CONFIG_FT5X0X_MULTITOUCH
+ ret = ft5x0x_i2c_rxdata(buf, 31);
+#else
+ ret = ft5x0x_i2c_rxdata(buf, 7);
+#endif
+ if (ret < 0) {
+ printk("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
+ return ret;
+ }
+#if 0
+ event->touch_point = buf[2] & 0x03;/* 0000 0011*/
+#endif
+ touch_point = buf[2] & 0x07;// 000 0111
+
+ if (touch_point == 0) {
+ ft5x0x_ts_release(data);
+ return 1;
+ }
+ memset(event, 0, sizeof(struct ts_event));
+ event->touch_point = touch_point;
+#ifdef CONFIG_FT5X0X_MULTITOUCH
+ switch (event->touch_point) {
+#ifdef CONFIG_TOUCHSCREEN_FT5206_WVGA
+//jixwei_add for Q100 ft5x06 convert from WVGA to HVGA
+ case 5:
+ event->x5 = (s16)(buf[0x1b] & 0x0F)<<8 | (s16)buf[0x1c];
+ event->y5 = (s16)(buf[0x1d] & 0x0F)<<8 | (s16)buf[0x1e];
+ event->x5 = event->x5*2/3;
+ event->y5 = event->y5*3/5;
+ case 4:
+ event->x4 = (s16)(buf[0x15] & 0x0F)<<8 | (s16)buf[0x16];
+ event->y4 = (s16)(buf[0x17] & 0x0F)<<8 | (s16)buf[0x18];
+ event->x4 = event->x4*2/3;
+ event->y4 = event->y4*3/5;
+ case 3:
+ event->x3 = (s16)(buf[0x0f] & 0x0F)<<8 | (s16)buf[0x10];
+ event->y3 = (s16)(buf[0x11] & 0x0F)<<8 | (s16)buf[0x12];
+ event->x3 = event->x3*2/3;
+ event->y3 = event->y3*3/5;
+ case 2:
+ event->x2 = (s16)(buf[9] & 0x0F)<<8 | (s16)buf[10];
+ event->y2 = (s16)(buf[11] & 0x0F)<<8 | (s16)buf[12];
+ event->x2 = event->x2*2/3;
+ event->y2 = event->y2*3/5;
+ case 1:
+ event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
+ event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
+ event->x1 = event->x1*2/3;
+ event->y1 = event->y1*3/5;
+#else
+ case 5:
+ event->x5 = (s16)(buf[0x1b] & 0x0F)<<8 | (s16)buf[0x1c];
+ event->y5 = (s16)(buf[0x1d] & 0x0F)<<8 | (s16)buf[0x1e];
+ case 4:
+ event->x4 = (s16)(buf[0x15] & 0x0F)<<8 | (s16)buf[0x16];
+ event->y4 = (s16)(buf[0x17] & 0x0F)<<8 | (s16)buf[0x18];
+ case 3:
+ event->x3 = (s16)(buf[0x0f] & 0x0F)<<8 | (s16)buf[0x10];
+ event->y3 = (s16)(buf[0x11] & 0x0F)<<8 | (s16)buf[0x12];
+ case 2:
+ event->x2 = (s16)(buf[9] & 0x0F)<<8 | (s16)buf[10];
+ event->y2 = (s16)(buf[11] & 0x0F)<<8 | (s16)buf[12];
+ case 1:
+ event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
+ event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
+#endif
+ break;
+ default:
+ return -1;
+ }
+#else
+ if (event->touch_point == 1) {
+ event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
+ event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
+ }
+#endif
+ event->pressure = 200;
+
+ PIXCIR_DBG("%d (%d, %d), (%d, %d)\n", event->touch_point, event->x1, event->y1, event->x2, event->y2);
+
+ return 0;
+}
+static void ft5x0x_report_value(struct ft5x0x_ts_struct *data)
+{
+ struct ts_event *event = &data->event;
+ /*lilonghui delet the log for debug2011-12-26*/
+ PIXCIR_DBG("==ft5x0x_report_value =\n");
+#ifdef CONFIG_FT5X0X_MULTITOUCH
+ input_report_key(data->input, BTN_TOUCH, 1);
+ switch(event->touch_point) {
+ case 5:
+ input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, event->pressure);
+ input_report_abs(data->input, ABS_MT_POSITION_X, event->x5);
+ input_report_abs(data->input, ABS_MT_POSITION_Y, event->y5);
+ input_report_abs(data->input, ABS_MT_WIDTH_MAJOR, 1);
+ input_mt_sync(data->input);
+ PIXCIR_DBG("===x5 = %d,y5 = %d ====\n",event->x5,event->y5);
+ case 4:
+ input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, event->pressure);
+ input_report_abs(data->input, ABS_MT_POSITION_X, event->x4);
+ input_report_abs(data->input, ABS_MT_POSITION_Y, event->y4);
+ input_report_abs(data->input, ABS_MT_WIDTH_MAJOR, 1);
+ input_mt_sync(data->input);
+ PIXCIR_DBG("===x4 = %d,y4 = %d ====\n",event->x4,event->y4);
+ case 3:
+ input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, event->pressure);
+ input_report_abs(data->input, ABS_MT_POSITION_X, event->x3);
+ input_report_abs(data->input, ABS_MT_POSITION_Y, event->y3);
+ input_report_abs(data->input, ABS_MT_WIDTH_MAJOR, 1);
+ input_mt_sync(data->input);
+ PIXCIR_DBG("===x3 = %d,y3 = %d ====\n",event->x3,event->y3);
+ case 2:
+ input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, event->pressure);
+ input_report_abs(data->input, ABS_MT_POSITION_X, event->x2);
+ input_report_abs(data->input, ABS_MT_POSITION_Y, event->y2);
+ input_report_abs(data->input, ABS_MT_WIDTH_MAJOR, 1);
+ input_mt_sync(data->input);
+ PIXCIR_DBG("===x2 = %d,y2 = %d ====\n",event->x2,event->y2);
+ case 1:
+ input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, event->pressure);
+ input_report_abs(data->input, ABS_MT_POSITION_X, event->x1);
+ input_report_abs(data->input, ABS_MT_POSITION_Y, event->y1);
+ input_report_abs(data->input, ABS_MT_WIDTH_MAJOR, 1);
+ input_mt_sync(data->input);
+ PIXCIR_DBG("===x1 = %d,y1 = %d ====\n",event->x1,event->y1);
+ default:
+ PIXCIR_DBG("==touch_point default =\n");
+ break;
+ }
+
+ input_report_abs(data->input, ABS_PRESSURE, event->pressure);
+#if 0
+ input_report_key(data->input, BTN_TOUCH, 1);
+#endif
+#else /* CONFIG_FT5X0X_MULTITOUCH*/
+ if (event->touch_point == 1) {
+ input_report_abs(data->input, ABS_X, event->x1);
+ input_report_abs(data->input, ABS_Y, event->y1);
+ input_report_abs(data->input, ABS_PRESSURE, event->pressure);
+ }
+ input_report_key(data->input, BTN_TOUCH, 1);
+#endif /* CONFIG_FT5X0X_MULTITOUCH*/
+ input_sync(data->input);
+
+ dev_dbg(&this_client->dev, "%s: 1:%d %d 2:%d %d \n", __func__,
+ event->x1, event->y1, event->x2, event->y2);
+}
+/* pixcir_ts_isr -- disable irq, and schedule
+ * irq: irq number
+ * dev_id: param when request_irq
+ * @return: IRQ status
+ */
+static irqreturn_t ft5x0x_ts_isr(int irq, void *dev_id)
+{
+ int ret = 0;
+ struct ft5x0x_ts_struct *tsdata = (struct ft5x0x_ts_struct *)dev_id;
+ PIXCIR_DBG("%s\n", __func__);
+ /*disable irq*/
+ disable_irq_nosync(irq);
+#if 1
+ if (!work_pending(&tsdata->pen_event_work)) {
+ queue_work(tsdata->ts_workqueue, &tsdata->pen_event_work);
+ }
+#else
+ {
+ ret = ft5x0x_read_data(tsdata);
+ if (ret == 0) {
+ ft5x0x_report_value(tsdata);
+ }
+#if 0
+ if (attb_read_val()) {
+ PIXCIR_DBG("%s: release\n",__func__);
+ input_report_key(tsdata->input, BTN_TOUCH, 0);
+ input_report_abs(tsdata->input, ABS_MT_TOUCH_MAJOR, 0);
+ input_sync(tsdata->input);
+ break;
+ }
+#endif
+ }
+ enable_irq(irq);
+#endif
+ return IRQ_HANDLED;
+
+}
+
+
+/* pixcir_ts_irq_work -- read tp register and report event
+
+ * @return: none
+ */
+ #if 1
+static void ft5x0x_ts_irq_work(struct work_struct *work)
+{
+ struct ft5x0x_ts_struct *tsdata = g_ft5x0x_ts;
+ ft5x0x_ts_poscheck(tsdata);
+ enable_irq(tsdata->client->irq);
+}
+#endif
+#ifdef CONFIG_PM_SLEEP
+static int ft5x0x_i2c_ts_suspend(struct device *dev)
+{
+#if 1
+ struct i2c_client *client = to_i2c_client(dev);
+ unsigned char wrbuf[2] = { 0 };
+ int ret;
+
+ //wrbuf[0] = 0x33;
+ //wrbuf[1] = 0x03; //enter into freeze mode;
+ /**************************************************************
+ wrbuf[1]: 0x00: Active mode
+ 0x01: Sleep mode
+ 0xA4: Sleep mode automatically switch
+ 0x03: Freeze mode
+ More details see application note 710 power manangement section
+ ****************************************************************/
+/*
+ ret = i2c_master_send(client, wrbuf, 2);
+ if(ret!=2) {
+ dev_err(&client->dev,
+ "%s: i2c_master_send failed(), ret=%d\n",
+ __func__, ret);
+ }
+*/
+ if (device_may_wakeup(&client->dev))
+ enable_irq_wake(client->irq);
+#endif
+ return 0;
+}
+
+static int ft5x0x_i2c_ts_resume(struct device *dev)
+{
+#if 1
+ struct i2c_client *client = to_i2c_client(dev);
+
+ PIXCIR_DBG(KERN_INFO "%s\n",__func__);
+ ft5x0x_reset(g_ft5x0x_ts->platform_data->reset_gpio_number);
+ if (device_may_wakeup(&client->dev))
+ disable_irq_wake(client->irq);
+#endif
+ return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(ft5x0x_dev_pm_ops,
+ ft5x0x_i2c_ts_suspend, ft5x0x_i2c_ts_resume);
+
+
+#ifdef FTS_FW_DOWNLOAD
+void delay_qt_ms(unsigned long w_ms)
+{
+ unsigned long i;
+ unsigned long j;
+
+ for (i = 0; i < w_ms; i++)
+ {
+ for (j = 0; j < 1000; j++)
+ {
+ udelay(1);
+ }
+ }
+}
+
+int ft5x0x_i2c_Write(char *writebuf, int writelen)
+{
+ int ret;
+
+ struct i2c_msg msg[] = {
+ {
+ .addr = this_client->addr,
+ .flags = 0,
+ .len = writelen,
+ .buf = writebuf,
+ },
+ };
+
+ ret = i2c_transfer(this_client->adapter, msg, 1);
+ if (ret < 0)
+ printk("[FTS] %s i2c write error: %d\n", __func__, ret);
+
+ return ret;
+}EXPORT_SYMBOL(ft5x0x_i2c_Write);
+
+int ft5x0x_write_reg(unsigned char regaddr, unsigned char regvalue)
+{
+ unsigned char buf[2];
+ buf[0] = regaddr;
+ buf[1] = regvalue;
+ return ft5x0x_i2c_Write(buf, sizeof(buf));
+}
+
+int ft5x0x_i2c_Read(char * writebuf, int writelen, char *readbuf, int readlen)
+{
+ int ret;
+
+ if(writelen > 0)
+ {
+ struct i2c_msg msgs[] = {
+ {
+ .addr = this_client->addr,
+ .flags = 0,
+ .len = writelen,
+ .buf = writebuf,
+ },
+ {
+ .addr = this_client->addr,
+ .flags = I2C_M_RD,
+ .len = readlen,
+ .buf = readbuf,
+ },
+ };
+ ret = i2c_transfer(this_client->adapter, msgs, 2);
+ if (ret < 0)
+ printk("[FTS] msg %s i2c read error: %d\n", __func__, ret);
+ }
+ else
+ {
+ struct i2c_msg msgs[] = {
+ {
+ .addr = this_client->addr,
+ .flags = I2C_M_RD,
+ .len = readlen,
+ .buf = readbuf,
+ },
+ };
+ ret = i2c_transfer(this_client->adapter, msgs, 1);
+ if (ret < 0)
+ printk("[FTS] msg %s i2c read error: %d\n", __func__, ret);
+ }
+ return ret;
+}EXPORT_SYMBOL(ft5x0x_i2c_Read);
+
+int ft5x0x_read_reg(unsigned char regaddr, unsigned char * regvalue)
+{
+ return ft5x0x_i2c_Read(&regaddr, 1, regvalue, 1);
+}
+
+int fts_ctpm_auto_clb(void)
+{
+ unsigned char uc_temp;
+ unsigned char i ;
+
+ printk("[FTS] start auto CLB.\n");
+ msleep(200);
+ ft5x0x_write_reg(0, 0x40);
+ delay_qt_ms(100); //make sure already enter factory mode
+ ft5x0x_write_reg(2, 0x4); //write command to start calibration
+ delay_qt_ms(300);
+ for(i=0;i<100;i++)
+ {
+ ft5x0x_read_reg(0,&uc_temp);
+ if ( ((uc_temp&0x70)>>4) == 0x0) //return to normal mode, calibration finish
+ {
+ break;
+ }
+ delay_qt_ms(200);
+ printk("[FTS] waiting calibration %d\n",i);
+ }
+
+ printk("[FTS] calibration OK.\n");
+
+ msleep(300);
+ ft5x0x_write_reg(0, 0x40); //goto factory mode
+ delay_qt_ms(100); //make sure already enter factory mode
+ ft5x0x_write_reg(2, 0x5); //store CLB result
+ delay_qt_ms(300);
+ ft5x0x_write_reg(0, 0x0); //return to normal mode
+ msleep(300);
+ printk("[FTS] store CLB result OK.\n");
+ return 0;
+}
+unsigned char fts_ctpm_get_i_file_ver(void)
+{
+ unsigned int ui_sz;
+ ui_sz = sizeof(CTPM_FW);
+ if (ui_sz > 2)
+ {
+ return CTPM_FW[ui_sz - 2];
+ }
+ else
+ {
+ //TBD, error handling?
+ return 0xff; //default value
+ }
+}
+E_UPGRADE_ERR_TYPE fts_ctpm_fw_upgrade(FTS_BYTE* pbt_buf, FTS_DWRD dw_lenth)
+{
+
+ FTS_BYTE reg_val[2] = {0};
+ FTS_DWRD i = 0;
+
+ FTS_DWRD packet_number;
+ FTS_DWRD j;
+ FTS_DWRD temp;
+ FTS_DWRD lenght;
+ FTS_BYTE packet_buf[FTS_PACKET_LENGTH + 6];
+ FTS_BYTE auc_i2c_write_buf[10];
+ FTS_BYTE bt_ecc;
+ int i_ret;
+
+ /*********Step 1:Reset CTPM *****/
+ /*write 0xaa to register 0xfc*/
+ ft5x0x_write_reg(0xfc,0xaa);
+ delay_qt_ms(50);
+ /*write 0x55 to register 0xfc*/
+ ft5x0x_write_reg(0xfc,0x55);
+ printk("[FTS] Step 1: Reset CTPM test\n");
+
+ delay_qt_ms(30);
+
+
+ /*********Step 2:Enter upgrade mode *****/
+ auc_i2c_write_buf[0] = 0x55;
+ auc_i2c_write_buf[1] = 0xaa;
+ do
+ {
+ i ++;
+ i_ret = ft5x0x_i2c_Write(auc_i2c_write_buf, 2);
+ delay_qt_ms(5);
+ }while(i_ret <= 0 && i < 5 );
+
+ /*********Step 3:check READ-ID***********************/
+ auc_i2c_write_buf[0] = 0x90;
+ auc_i2c_write_buf[1] = auc_i2c_write_buf[2] = auc_i2c_write_buf[3] = 0x00;
+ //ft5x0x_i2c_Write(auc_i2c_write_buf, 4);
+
+ ft5x0x_i2c_Read(auc_i2c_write_buf, 4, reg_val, 2);
+ if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
+ {
+ printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
+ }
+ else
+ {
+ return ERR_READID;
+ }
+ auc_i2c_write_buf[0] = 0xcd;
+ ft5x0x_i2c_Read(auc_i2c_write_buf, 1, reg_val, 1);
+ printk("[FTS] bootloader version = 0x%x\n", reg_val[0]);
+
+ /*********Step 4:erase app and panel paramenter area ********************/
+ auc_i2c_write_buf[0] = 0x61;
+ ft5x0x_i2c_Write(auc_i2c_write_buf, 1); //erase app area
+ delay_qt_ms(1500);
+
+ auc_i2c_write_buf[0] = 0x63;
+ ft5x0x_i2c_Write(auc_i2c_write_buf, 1); //erase panel parameter area
+ delay_qt_ms(100);
+ printk("[FTS] Step 4: erase. \n");
+
+ /*********Step 5:write firmware(FW) to ctpm flash*********/
+ bt_ecc = 0;
+ printk("[FTS] Step 5: start upgrade. \n");
+ dw_lenth = dw_lenth - 8;
+ packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
+ packet_buf[0] = 0xbf;
+ packet_buf[1] = 0x00;
+ for (j=0;j<packet_number;j++)
+ {
+ temp = j * FTS_PACKET_LENGTH;
+ packet_buf[2] = (FTS_BYTE)(temp>>8);
+ packet_buf[3] = (FTS_BYTE)temp;
+ lenght = FTS_PACKET_LENGTH;
+ packet_buf[4] = (FTS_BYTE)(lenght>>8);
+ packet_buf[5] = (FTS_BYTE)lenght;
+
+ for (i=0;i<FTS_PACKET_LENGTH;i++)
+ {
+ packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
+ bt_ecc ^= packet_buf[6+i];
+ }
+
+ ft5x0x_i2c_Write(packet_buf, FTS_PACKET_LENGTH+6);
+ delay_qt_ms(FTS_PACKET_LENGTH/6 + 1);
+ if ((j * FTS_PACKET_LENGTH % 1024) == 0)
+ {
+ printk("[FTS] upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
+ }
+ }
+
+ if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
+ {
+ temp = packet_number * FTS_PACKET_LENGTH;
+ packet_buf[2] = (FTS_BYTE)(temp>>8);
+ packet_buf[3] = (FTS_BYTE)temp;
+
+ temp = (dw_lenth) % FTS_PACKET_LENGTH;
+ packet_buf[4] = (FTS_BYTE)(temp>>8);
+ packet_buf[5] = (FTS_BYTE)temp;
+
+ for (i=0;i<temp;i++)
+ {
+ packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
+ bt_ecc ^= packet_buf[6+i];
+ }
+
+ ft5x0x_i2c_Write(packet_buf, temp+6);
+ delay_qt_ms(20);
+ }
+
+ //send the last six byte
+ for (i = 0; i<6; i++)
+ {
+ temp = 0x6ffa + i;
+ packet_buf[2] = (FTS_BYTE)(temp>>8);
+ packet_buf[3] = (FTS_BYTE)temp;
+ temp =1;
+ packet_buf[4] = (FTS_BYTE)(temp>>8);
+ packet_buf[5] = (FTS_BYTE)temp;
+ packet_buf[6] = pbt_buf[ dw_lenth + i];
+ bt_ecc ^= packet_buf[6];
+
+ ft5x0x_i2c_Write(packet_buf, 7);
+ delay_qt_ms(20);
+ }
+
+ /*********Step 6: read out checksum***********************/
+ /*send the opration head*/
+ auc_i2c_write_buf[0] = 0xcc;
+ ft5x0x_i2c_Read(auc_i2c_write_buf, 1, reg_val, 1);
+
+ printk("[FTS] Step 6: ecc read 0x%x, new firmware 0x%x. \n", reg_val[0], bt_ecc);
+ if(reg_val[0] != bt_ecc)
+ {
+ return ERR_ECC;
+ }
+
+ /*********Step 7: reset the new FW***********************/
+ auc_i2c_write_buf[0] = 0x07;
+ ft5x0x_i2c_Write(auc_i2c_write_buf, 1);
+ msleep(300); //make sure CTP startup normally
+
+ return ERR_OK;
+}
+
+int fts_ctpm_fw_upgrade_with_i_file(void)
+{
+ FTS_BYTE* pbt_buf = NULL;
+ int i_ret;
+
+ //=========FW upgrade========================*/
+ pbt_buf = CTPM_FW;
+ /*call the upgrade function*/
+ i_ret = fts_ctpm_fw_upgrade(pbt_buf,sizeof(CTPM_FW));
+ if (i_ret != 0)
+ {
+ printk("[FTS] upgrade failed i_ret = %d.\n", i_ret);
+ //error handling ...
+ //TBD
+ }
+ else
+ {
+ printk("[FTS] upgrade successfully.\n");
+ fts_ctpm_auto_clb(); //start auto CLB
+ }
+
+ return i_ret;
+}
+int fts_ctpm_auto_upg(void)
+{
+ unsigned char uc_host_fm_ver=FT5x0x_REG_FW_VER;
+ unsigned char uc_tp_fm_ver;
+ int i_ret;
+
+ ft5x0x_read_reg(FT5x0x_REG_FW_VER, &uc_tp_fm_ver);
+ uc_host_fm_ver = fts_ctpm_get_i_file_ver();
+ if ( uc_tp_fm_ver == FT5x0x_REG_FW_VER || //the firmware in touch panel maybe corrupted
+ uc_tp_fm_ver < uc_host_fm_ver //the firmware in host flash is new, need upgrade
+ )
+ {
+ msleep(100);
+ printk("[FTS] uc_tp_fm_ver = 0x%x, uc_host_fm_ver = 0x%x\n",
+ uc_tp_fm_ver, uc_host_fm_ver);
+ i_ret = fts_ctpm_fw_upgrade_with_i_file();
+ if (i_ret == 0)
+ {
+ msleep(300);
+ uc_host_fm_ver = fts_ctpm_get_i_file_ver();
+ printk("[FTS] upgrade to new version 0x%x\n", uc_host_fm_ver);
+ }
+ else
+ {
+ printk("[FTS] upgrade failed ret=%d.\n", i_ret);
+ }
+ }
+
+ return 0;
+}
+#define FTS_SETTING_BUF_LEN 128
+
+unsigned char FTS_CTPM_GetVendorID_Info(void)
+{
+ unsigned char buf[FTS_SETTING_BUF_LEN];
+ unsigned char reg_val[2] = {0};
+ unsigned char auc_i2c_write_buf[10];
+ unsigned char packet_buf[FTS_SETTING_BUF_LEN + 6];
+ unsigned int i = 0;
+ int i_ret;
+
+ /*********Step 1:Reset CTPM *****/
+ /*write 0xaa to register 0xfc*/
+ ft5x0x_write_reg(0xfc,0xaa);
+ delay_qt_ms(50);
+ /*write 0x55 to register 0xfc*/
+ ft5x0x_write_reg(0xfc,0x55);
+ printk("[FTS] Step 1: GetVendorID Reset CTPM test\n");
+
+ delay_qt_ms(30);
+
+ /*********Step 2:Enter upgrade mode *****/
+ auc_i2c_write_buf[0] = 0x55;
+ auc_i2c_write_buf[1] = 0xaa;
+ do
+ {
+ i ++;
+ //i_ret = ft5x0x_i2c_txdata(auc_i2c_write_buf, 2);
+ i_ret = ft5x0x_i2c_Write(auc_i2c_write_buf, 2);
+ delay_qt_ms(5);
+ }while(i_ret <= 0 && i < 5 );
+
+ /*********Step 3:check READ-ID***********************/
+ auc_i2c_write_buf[0] = 0x90;
+ auc_i2c_write_buf[1] = auc_i2c_write_buf[2] = auc_i2c_write_buf[3] = 0x00;
+ ft5x0x_i2c_Read(auc_i2c_write_buf, 4, reg_val, 2);
+ if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
+ {
+ printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
+ }
+ else
+ {
+ return ERR_READID;
+ }
+ auc_i2c_write_buf[0] = 0xcd;
+ ft5x0x_i2c_Read(auc_i2c_write_buf, 1, reg_val, 1);
+ printk("bootloader version = 0x%x\n", reg_val[0]);
+
+ /* --------- read current project setting ---------- */
+ //set read start address
+ buf[0] = 0x3;
+ buf[1] = 0x0;
+ buf[2] = 0x78;
+ buf[3] = 0x4;
+ //ft5x0x_i2c_Write(buf, 4);
+ //byte_read(buf, FTS_SETTING_BUF_LEN);
+ ft5x0x_i2c_Read(buf, 4, buf, 1);
+ //I2C slave address (8 bit address)
+ //IO Voltage 0---3.3v; 1----1.8v
+ //TP panel factory ID
+ printk("[FTS] old setting: uc_panel_factory_id = 0x%x\n", buf[0]);
+
+ /********* reset the new FW***********************/
+ auc_i2c_write_buf[0] = 0x07;
+ ft5x0x_i2c_Write(auc_i2c_write_buf, 1);
+
+ msleep(300);
+
+ return buf[0]; //TP panel factory ID
+}
+#endif
+
+
+/* pixcir_i2c_ts_probe -- pixcir probe function
+ * initalize PIXCIR hardware configuration
+ * register input system, and request irq
+ * @return: error code; 0: successful
+ */
+static int __devinit ft5x0x_i2c_ts_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct ft5x0x_ts_platform_data *pdata = client->dev.platform_data;
+ struct ft5x0x_ts_struct *tsdata;
+ struct input_dev *input;
+ struct device *dev;
+ struct i2c_dev *i2c_dev;
+ int i, error;
+
+ PIXCIR_DBG(KERN_INFO "%s: probe\n",__func__);
+
+ for(i=0; i<MAX_FINGER_NUM*2; i++) {
+ point_slot[i].active = 0;
+ }
+ this_client = client;
+ tsdata = kzalloc(sizeof(*tsdata), GFP_KERNEL);
+ input = input_allocate_device();
+ if (!tsdata || !input) {
+ dev_err(&client->dev, "Failed to allocate driver data!\n");
+ error = -ENOMEM;
+ goto err_free_mem;
+ }
+ g_ft5x0x_ts = tsdata;
+
+ PIXCIR_DBG("%s: irq_pin=%d; reset_pin=%d", \
+ __func__, pdata->irq_gpio_number,pdata->reset_gpio_number);
+
+ tsdata->platform_data = pdata;
+
+ /*pin init*/
+ pxicir_ts_pininit(pdata->irq_gpio_number,pdata->reset_gpio_number);
+#if 0
+ /*get regulator*/
+ tsdata->reg_vdd = regulator_get(&client->dev, REGU_NAME_TP);
+#endif
+ /*enable VDD*/
+ ft5x0x_ts_pwron(tsdata->reg_vdd);
+
+ /*reset TP chip*/
+ ft5x0x_reset(pdata->reset_gpio_number);
+ //msleep(100);
+ msleep(300);
+
+ //get irq number
+ client->irq = gpio_to_irq(pdata->irq_gpio_number);
+ tsdata->ft5x0x_irq = client->irq;
+ PIXCIR_DBG("%s: irq=%d",__func__, client->irq);
+
+ //register virtual keys
+#ifdef TOUCH_VIRTUAL_KEYS
+ ft5x0x_ts_virtual_keys_init();
+#endif
+
+ tsdata->client = client;
+ tsdata->input = input;
+
+ input->name = client->name;
+ input->id.bustype = BUS_I2C;
+ input->dev.parent = &client->dev;
+
+ __set_bit(EV_KEY, input->evbit);
+ __set_bit(EV_ABS, input->evbit);
+ __set_bit(EV_SYN, input->evbit);
+ __set_bit(BTN_TOUCH, input->keybit);
+
+ __set_bit(ABS_MT_TOUCH_MAJOR, input->absbit);
+ __set_bit(ABS_MT_POSITION_X, input->absbit);
+ __set_bit(ABS_MT_POSITION_Y, input->absbit);
+ __set_bit(ABS_MT_WIDTH_MAJOR, input->absbit);
+
+ __set_bit(KEY_MENU, input->keybit);
+ __set_bit(KEY_BACK, input->keybit);
+ __set_bit(KEY_HOME, input->keybit);
+ __set_bit(KEY_SEARCH, input->keybit);
+
+ input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
+ input_set_abs_params(input, ABS_MT_POSITION_X, 0, X_MAX, 0, 0);
+ input_set_abs_params(input, ABS_MT_POSITION_Y, 0, Y_MAX, 0, 0);
+ input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);
+
+
+ input_set_drvdata(input, tsdata);
+#if 1
+ INIT_WORK(&tsdata->pen_event_work, ft5x0x_ts_irq_work);
+ tsdata->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));
+#endif
+ error = request_irq(client->irq, ft5x0x_ts_isr, IRQF_TRIGGER_FALLING, client->name, tsdata);
+ if (error) {
+ printk(KERN_ERR "%s:Unable to request touchscreen IRQ.\n",__func__);
+ goto err_free_mem;
+ }
+
+ disable_irq_nosync(client->irq);
+
+ error = input_register_device(input);
+ if (error)
+ goto err_free_irq;
+ i2c_set_clientdata(client, tsdata);
+ device_init_wakeup(&client->dev, 1);
+
+#ifdef FTS_FW_DOWNLOAD
+{
+ unsigned char uc_reg_addr;
+ unsigned char uc_reg_value;
+ unsigned char vendor_ID = ERR_READID;
+ vendor_ID = FTS_CTPM_GetVendorID_Info();
+ printk("[FTS] FTS_CTPM_GetVendorID_Info = 0x%x\n", vendor_ID);
+
+ if(vendor_ID != ERR_READID)
+ {
+ if(vendor_ID == 0x57)
+ fts_ctpm_auto_upg();
+ }
+
+ uc_reg_addr = FT5x0x_REG_FW_VER;
+ ft5x0x_i2c_Read(&uc_reg_addr, 1, &uc_reg_value, 1);
+ printk("[FTS] Firmware version = 0x%x\n", uc_reg_value);
+ }
+#endif
+
+
+ /*********************************Bee-0928-TOP****************************************/
+ i2c_dev = get_free_i2c_dev(client->adapter);
+ if (IS_ERR(i2c_dev)) {
+ error = PTR_ERR(i2c_dev);
+ return error;
+ }
+ dev = device_create(i2c_dev_class, &client->adapter->dev, MKDEV(I2C_MAJOR,
+ client->adapter->nr), NULL, "ft5x0x_i2c_ts%d", 0);
+ if (IS_ERR(dev)) {
+ error = PTR_ERR(dev);
+ return error;
+ }
+ /*********************************Bee-0928-BOTTOM****************************************/
+ tsdata->ft5x0x_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+ tsdata->ft5x0x_early_suspend.suspend = ft5x0x_ts_suspend;
+ tsdata->ft5x0x_early_suspend.resume = ft5x0x_ts_resume;
+ register_early_suspend(&tsdata->ft5x0x_early_suspend);
+
+ if((error=ft5x0x_tx_config())<0) {
+ printk(KERN_ERR "%s: I2C error\n",__func__);
+ goto err_i2c;
+ }
+ ft5x0x_create_sysfs(client);
+
+ PIXCIR_DBG(KERN_INFO "%s:insmod successfully!\n",__func__);
+
+ enable_irq(client->irq);
+ return 0;
+
+ printk(KERN_ERR "%s:insmod Fail!\n",__func__);
+
+err_i2c:
+ unregister_early_suspend(&tsdata->ft5x0x_early_suspend);
+err_free_irq:
+ free_irq(client->irq, tsdata);
+err_free_mem:
+ input_free_device(input);
+ kfree(tsdata);
+ return error;
+}
+
+
+/* pixcir_i2c_ts_remove -- remove pixcir from device list
+ * @return: error code; 0: successful
+ */
+static int __devexit ft5x0x_i2c_ts_remove(struct i2c_client *client)
+{
+ int error;
+ struct i2c_dev *i2c_dev;
+ struct ft5x0x_ts_struct *tsdata = i2c_get_clientdata(client);
+
+ device_init_wakeup(&client->dev, 0);
+
+ tsdata->exiting = true;
+ mb();
+ free_irq(client->irq, tsdata);
+
+ /*********************************Bee-0928-TOP****************************************/
+ i2c_dev = get_free_i2c_dev(client->adapter);
+ if (IS_ERR(i2c_dev)) {
+ error = PTR_ERR(i2c_dev);
+ return error;
+ }
+
+ return_i2c_dev(i2c_dev);
+ device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, client->adapter->nr));
+ /*********************************Bee-0928-BOTTOM****************************************/
+ unregister_early_suspend(&tsdata->ft5x0x_early_suspend);
+ //sprd_free_gpio_irq(pixcir_irq);
+ input_unregister_device(tsdata->input);
+ kfree(tsdata);
+
+ return 0;
+}
+
+/*************************************Bee-0928****************************************/
+/* pixcir_open */
+/*************************************Bee-0928****************************************/
+static int ft5x0x_open(struct inode *inode, struct file *file)
+{
+ int subminor;
+ struct i2c_client *client;
+ struct i2c_adapter *adapter;
+ struct i2c_dev *i2c_dev;
+ int ret = 0;
+ PIXCIR_DBG("enter ft5x0x_open function\n");
+
+ subminor = iminor(inode);
+
+ i2c_dev = i2c_dev_get_by_minor(subminor);
+ if (!i2c_dev) {
+ printk(KERN_ERR "error i2c_dev\n");
+ return -ENODEV;
+ }
+
+ adapter = i2c_get_adapter(i2c_dev->adap->nr);
+ if (!adapter) {
+ return -ENODEV;
+ }
+
+ client = kzalloc(sizeof(*client), GFP_KERNEL);
+ if (!client) {
+ i2c_put_adapter(adapter);
+ ret = -ENOMEM;
+ }
+
+ snprintf(client->name, I2C_NAME_SIZE, "ft5x0x_i2c_ts%d", adapter->nr);
+ client->driver = &ft5x0x_i2c_ts_driver;
+ client->adapter = adapter;
+
+ file->private_data = client;
+
+ return 0;
+}
+
+/*************************************Bee-0928****************************************/
+/* pixcir_ioctl */
+/*************************************Bee-0928****************************************/
+static long ft5x0x_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ struct i2c_client *client = (struct i2c_client *) file->private_data;
+
+ PIXCIR_DBG("ft5x0x_ioctl(),cmd = %d,arg = %ld\n", cmd, arg);
+
+
+ switch (cmd)
+ {
+ case CALIBRATION_FLAG: //CALIBRATION_FLAG = 1
+ client->addr = SLAVE_ADDR;
+ status_reg = CALIBRATION_FLAG;
+ break;
+
+ case BOOTLOADER: //BOOTLOADER = 7
+ client->addr = BOOTLOADER_ADDR;
+ status_reg = BOOTLOADER;
+
+ ft5x0x_reset(g_ft5x0x_ts->platform_data->reset_gpio_number);
+ mdelay(5);
+ break;
+
+ case RESET_TP: //RESET_TP = 9
+ ft5x0x_reset(g_ft5x0x_ts->platform_data->reset_gpio_number);
+ break;
+
+ case ENABLE_IRQ: //ENABLE_IRQ = 10
+ status_reg = 0;
+ enable_irq(g_ft5x0x_ts->client->irq);
+ break;
+
+ case DISABLE_IRQ: //DISABLE_IRQ = 11
+ disable_irq_nosync(g_ft5x0x_ts->client->irq);
+ break;
+
+ case BOOTLOADER_STU: //BOOTLOADER_STU = 12
+ client->addr = BOOTLOADER_ADDR;
+ status_reg = BOOTLOADER_STU;
+
+ ft5x0x_reset(g_ft5x0x_ts->platform_data->reset_gpio_number);
+ mdelay(5);
+
+ case ATTB_VALUE: //ATTB_VALUE = 13
+ client->addr = SLAVE_ADDR;
+ status_reg = ATTB_VALUE;
+ break;
+
+ default:
+ client->addr = SLAVE_ADDR;
+ status_reg = 0;
+ break;
+ }
+ return 0;
+}
+
+/***********************************Bee-0928****************************************/
+/* pixcir_read */
+/***********************************Bee-0928****************************************/
+static ssize_t ft5x0x_read (struct file *file, char __user *buf, size_t count,loff_t *offset)
+{
+ struct i2c_client *client = (struct i2c_client *)file->private_data;
+ unsigned char *tmp, bootloader_stu[4], attb_value[1];
+ int ret = 0;
+
+ switch(status_reg)
+ {
+ case BOOTLOADER_STU:
+ i2c_master_recv(client, bootloader_stu, sizeof(bootloader_stu));
+ if (ret!=sizeof(bootloader_stu)) {
+ dev_err(&client->dev,
+ "%s: BOOTLOADER_STU: i2c_master_recv() failed, ret=%d\n",
+ __func__, ret);
+ return -EFAULT;
+ }
+
+ ret = copy_to_user(buf, bootloader_stu, sizeof(bootloader_stu));
+ if(ret) {
+ dev_err(&client->dev,
+ "%s: BOOTLOADER_STU: copy_to_user() failed.\n", __func__);
+ return -EFAULT;
+ }else {
+ ret = 4;
+ }
+ break;
+
+ case ATTB_VALUE:
+ attb_value[0] = attb_read_val(g_ft5x0x_ts->platform_data->irq_gpio_number);
+ if(copy_to_user(buf, attb_value, sizeof(attb_value))) {
+ dev_err(&client->dev,
+ "%s: ATTB_VALUE: copy_to_user() failed.\n", __func__);
+ return -EFAULT;
+ }else {
+ ret = 1;
+ }
+ break;
+
+ default:
+ tmp = kmalloc(count,GFP_KERNEL);
+ if (tmp==NULL)
+ return -ENOMEM;
+
+ ret = i2c_master_recv(client, tmp, count);
+ if (ret != count) {
+ dev_err(&client->dev,
+ "%s: default: i2c_master_recv() failed, ret=%d\n",
+ __func__, ret);
+ return -EFAULT;
+ }
+
+ if(copy_to_user(buf, tmp, count)) {
+ dev_err(&client->dev,
+ "%s: default: copy_to_user() failed.\n", __func__);
+ kfree(tmp);
+ return -EFAULT;
+ }
+ kfree(tmp);
+ break;
+ }
+ return ret;
+}
+
+/***********************************Bee-0928****************************************/
+/* ft5x0x_write */
+/***********************************Bee-0928****************************************/
+static ssize_t ft5x0x_write(struct file *file,const char __user *buf,size_t count, loff_t *ppos)
+{
+ struct i2c_client *client;
+ unsigned char *tmp, bootload_data[143];
+ int ret=0, i=0;
+
+ client = file->private_data;
+
+ switch(status_reg)
+ {
+ case CALIBRATION_FLAG: //CALIBRATION_FLAG=1
+#if 0
+ tmp = kmalloc(count,GFP_KERNEL);
+ if (tmp==NULL)
+ return -ENOMEM;
+
+ if (copy_from_user(tmp,buf,count)) {
+ dev_err(&client->dev,
+ "%s: CALIBRATION_FLAG: copy_from_user() failed.\n", __func__);
+ kfree(tmp);
+ return -EFAULT;
+ }
+
+ ret = i2c_master_send(client,tmp,count);
+ if (ret!=count ) {
+ dev_err(&client->dev,
+ "%s: CALIBRATION: i2c_master_send() failed, ret=%d\n",
+ __func__, ret);
+ kfree(tmp);
+ return -EFAULT;
+ }
+
+ while(!attb_read_val(g_pixcir_ts->platform_data->irq_gpio_number)) {
+ msleep(100);
+ i++;
+ if(i>99)
+ break; //10s no high aatb break
+ } //waiting to finish the calibration.(pixcir application_note_710_v3 p43)
+
+ kfree(tmp);
+#endif
+ break;
+
+ case BOOTLOADER:
+#if 0
+ memset(bootload_data, 0, sizeof(bootload_data));
+
+ if (copy_from_user(bootload_data, buf, count)) {
+ dev_err(&client->dev,
+ "%s: BOOTLOADER: copy_from_user() failed.\n", __func__);
+ return -EFAULT;
+ }
+
+ ret = i2c_master_send(client, bootload_data, count);
+ if(ret!=count) {
+ dev_err(&client->dev,
+ "%s: BOOTLOADER: i2c_master_send() failed, ret = %d\n",
+ __func__, ret);
+ return -EFAULT;
+ }
+#endif
+ break;
+
+ default:
+ tmp = kmalloc(count,GFP_KERNEL);
+ if (tmp==NULL)
+ return -ENOMEM;
+
+ if (copy_from_user(tmp,buf,count)) {
+ dev_err(&client->dev,
+ "%s: default: copy_from_user() failed.\n", __func__);
+ kfree(tmp);
+ return -EFAULT;
+ }
+
+ ret = i2c_master_send(client,tmp,count);
+ if (ret!=count ) {
+ dev_err(&client->dev,
+ "%s: default: i2c_master_send() failed, ret=%d\n",
+ __func__, ret);
+ kfree(tmp);
+ return -EFAULT;
+ }
+ kfree(tmp);
+ break;
+ }
+ return ret;
+}
+
+/***********************************Bee-0928****************************************/
+/* pixcir_release */
+/***********************************Bee-0928****************************************/
+static int ft5x0x_release(struct inode *inode, struct file *file)
+{
+ struct i2c_client *client = file->private_data;
+
+ PIXCIR_DBG("enter ft5x0x_release funtion\n");
+
+ i2c_put_adapter(client->adapter);
+ kfree(client);
+ file->private_data = NULL;
+
+ return 0;
+}
+
+/*********************************Bee-0928-TOP****************************************/
+static const struct file_operations ft5x0x_i2c_ts_fops =
+{ .owner = THIS_MODULE,
+ .read = ft5x0x_read,
+ .write = ft5x0x_write,
+ .open = ft5x0x_open,
+ .unlocked_ioctl = ft5x0x_ioctl,
+ .release = ft5x0x_release,
+};
+/*********************************Bee-0928-BOTTOM****************************************/
+
+
+static const struct i2c_device_id ft5x0x_i2c_ts_id[] = {
+ { FT5X0X_DEVICE_NAME, 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, ft5x0x_i2c_ts_id);
+
+static struct i2c_driver ft5x0x_i2c_ts_driver = {
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = "ft5x0x_i2c_ts_v3.2.0A",
+ },
+ .probe = ft5x0x_i2c_ts_probe,
+ .remove = __devexit_p(ft5x0x_i2c_ts_remove),
+ .id_table = ft5x0x_i2c_ts_id,
+};
+
+static int __init ft5x0x_i2c_ts_init(void)
+{
+ int ret;
+ PIXCIR_DBG("%s",__func__);
+ /*********************************Bee-0928-TOP****************************************/
+ ret = register_chrdev(I2C_MAJOR,"ft5x0x_i2c_ts",&ft5x0x_i2c_ts_fops);
+ if (ret) {
+ printk(KERN_ERR "%s:register chrdev failed\n",__func__);
+ return ret;
+ }
+
+ i2c_dev_class = class_create(THIS_MODULE, "ft5x0x_i2c_dev");
+ if (IS_ERR(i2c_dev_class)) {
+ ret = PTR_ERR(i2c_dev_class);
+ class_destroy(i2c_dev_class);
+ }
+ /********************************Bee-0928-BOTTOM******************************************/
+ return i2c_add_driver(&ft5x0x_i2c_ts_driver);
+}
+
+static void __exit ft5x0x_i2c_ts_exit(void)
+{
+ i2c_del_driver(&ft5x0x_i2c_ts_driver);
+ /********************************Bee-0928-TOP******************************************/
+ class_destroy(i2c_dev_class);
+ unregister_chrdev(I2C_MAJOR,"ft5x0x_i2c_ts");
+ /********************************Bee-0928-BOTTOM******************************************/
+}
+
+module_init(ft5x0x_i2c_ts_init);
+module_exit(ft5x0x_i2c_ts_exit);
+
+MODULE_AUTHOR("Yunlong wang <yunlong.wang@spreadtrum.com>");
+MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver");
+MODULE_LICENSE("GPL");
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-15 19:32:23 +0000