Input: synaptics_i2c_rmi: Driver for Synaptics Touchscreens using RMI over I2C.
Arve Hjønnevåg [Wed, 22 Aug 2007 04:56:46 +0000 (21:56 -0700)]
Signed-off-by: Arve Hjønnevåg <arve@android.com>

Input: synaptics_i2c_rmi: disable_irq -> disable_irq_nosync

Also remove duplicate swap macro

Change-Id: I77266431ba5c267a5d92c4bdc2f127a5297065a8
Signed-off-by: Arve Hjønnevåg <arve@android.com>

drivers/input/touchscreen/Kconfig
drivers/input/touchscreen/Makefile
drivers/input/touchscreen/synaptics_i2c_rmi.c [new file with mode: 0644]
include/linux/synaptics_i2c_rmi.h [new file with mode: 0644]

index 4af2a18..d7e6ec8 100644 (file)
@@ -406,6 +406,12 @@ config TOUCHSCREEN_TNETV107X
          To compile this driver as a module, choose M here: the
          module will be called tnetv107x-ts.
 
+config TOUCHSCREEN_SYNAPTICS_I2C_RMI
+       tristate "Synaptics i2c touchscreen"
+       depends on I2C
+       help
+         This enables support for Synaptics RMI over I2C based touchscreens.
+
 config TOUCHSCREEN_TOUCHRIGHT
        tristate "Touchright serial touchscreen"
        select SERIO
index 496091e..fc83e98 100644 (file)
@@ -46,6 +46,7 @@ obj-$(CONFIG_TOUCHSCREEN_S3C2410)     += s3c2410_ts.o
 obj-$(CONFIG_TOUCHSCREEN_ST1232)       += st1232.o
 obj-$(CONFIG_TOUCHSCREEN_STMPE)                += stmpe-ts.o
 obj-$(CONFIG_TOUCHSCREEN_TNETV107X)    += tnetv107x-ts.o
+obj-$(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI)    += synaptics_i2c_rmi.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)   += touchit213.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)   += touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)     += touchwin.o
diff --git a/drivers/input/touchscreen/synaptics_i2c_rmi.c b/drivers/input/touchscreen/synaptics_i2c_rmi.c
new file mode 100644 (file)
index 0000000..5729602
--- /dev/null
@@ -0,0 +1,675 @@
+/* drivers/input/keyboard/synaptics_i2c_rmi.c
+ *
+ * Copyright (C) 2007 Google, 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/module.h>
+#include <linux/delay.h>
+#include <linux/earlysuspend.h>
+#include <linux/hrtimer.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/synaptics_i2c_rmi.h>
+
+static struct workqueue_struct *synaptics_wq;
+
+struct synaptics_ts_data {
+       uint16_t addr;
+       struct i2c_client *client;
+       struct input_dev *input_dev;
+       int use_irq;
+       bool has_relative_report;
+       struct hrtimer timer;
+       struct work_struct  work;
+       uint16_t max[2];
+       int snap_state[2][2];
+       int snap_down_on[2];
+       int snap_down_off[2];
+       int snap_up_on[2];
+       int snap_up_off[2];
+       int snap_down[2];
+       int snap_up[2];
+       uint32_t flags;
+       int reported_finger_count;
+       int8_t sensitivity_adjust;
+       int (*power)(int on);
+       struct early_suspend early_suspend;
+};
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void synaptics_ts_early_suspend(struct early_suspend *h);
+static void synaptics_ts_late_resume(struct early_suspend *h);
+#endif
+
+static int synaptics_init_panel(struct synaptics_ts_data *ts)
+{
+       int ret;
+
+       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10); /* page select = 0x10 */
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
+               goto err_page_select_failed;
+       }
+       ret = i2c_smbus_write_byte_data(ts->client, 0x41, 0x04); /* Set "No Clip Z" */
+       if (ret < 0)
+               printk(KERN_ERR "i2c_smbus_write_byte_data failed for No Clip Z\n");
+
+       ret = i2c_smbus_write_byte_data(ts->client, 0x44,
+                                       ts->sensitivity_adjust);
+       if (ret < 0)
+               pr_err("synaptics_ts: failed to set Sensitivity Adjust\n");
+
+err_page_select_failed:
+       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x04); /* page select = 0x04 */
+       if (ret < 0)
+               printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
+       ret = i2c_smbus_write_byte_data(ts->client, 0xf0, 0x81); /* normal operation, 80 reports per second */
+       if (ret < 0)
+               printk(KERN_ERR "synaptics_ts_resume: i2c_smbus_write_byte_data failed\n");
+       return ret;
+}
+
+static void synaptics_ts_work_func(struct work_struct *work)
+{
+       int i;
+       int ret;
+       int bad_data = 0;
+       struct i2c_msg msg[2];
+       uint8_t start_reg;
+       uint8_t buf[15];
+       struct synaptics_ts_data *ts = container_of(work, struct synaptics_ts_data, work);
+       int buf_len = ts->has_relative_report ? 15 : 13;
+
+       msg[0].addr = ts->client->addr;
+       msg[0].flags = 0;
+       msg[0].len = 1;
+       msg[0].buf = &start_reg;
+       start_reg = 0x00;
+       msg[1].addr = ts->client->addr;
+       msg[1].flags = I2C_M_RD;
+       msg[1].len = buf_len;
+       msg[1].buf = buf;
+
+       /* printk("synaptics_ts_work_func\n"); */
+       for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
+               ret = i2c_transfer(ts->client->adapter, msg, 2);
+               if (ret < 0) {
+                       printk(KERN_ERR "synaptics_ts_work_func: i2c_transfer failed\n");
+                       bad_data = 1;
+               } else {
+                       /* printk("synaptics_ts_work_func: %x %x %x %x %x %x" */
+                       /*        " %x %x %x %x %x %x %x %x %x, ret %d\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], */
+                       /*        buf[12], buf[13], buf[14], ret); */
+                       if ((buf[buf_len - 1] & 0xc0) != 0x40) {
+                               printk(KERN_WARNING "synaptics_ts_work_func:"
+                                      " bad read %x %x %x %x %x %x %x %x %x"
+                                      " %x %x %x %x %x %x, ret %d\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],
+                                      buf[12], buf[13], buf[14], ret);
+                               if (bad_data)
+                                       synaptics_init_panel(ts);
+                               bad_data = 1;
+                               continue;
+                       }
+                       bad_data = 0;
+                       if ((buf[buf_len - 1] & 1) == 0) {
+                               /* printk("read %d coordinates\n", i); */
+                               break;
+                       } else {
+                               int pos[2][2];
+                               int f, a;
+                               int base;
+                               /* int x = buf[3] | (uint16_t)(buf[2] & 0x1f) << 8; */
+                               /* int y = buf[5] | (uint16_t)(buf[4] & 0x1f) << 8; */
+                               int z = buf[1];
+                               int w = buf[0] >> 4;
+                               int finger = buf[0] & 7;
+
+                               /* int x2 = buf[3+6] | (uint16_t)(buf[2+6] & 0x1f) << 8; */
+                               /* int y2 = buf[5+6] | (uint16_t)(buf[4+6] & 0x1f) << 8; */
+                               /* int z2 = buf[1+6]; */
+                               /* int w2 = buf[0+6] >> 4; */
+                               /* int finger2 = buf[0+6] & 7; */
+
+                               /* int dx = (int8_t)buf[12]; */
+                               /* int dy = (int8_t)buf[13]; */
+                               int finger2_pressed;
+
+                               /* printk("x %4d, y %4d, z %3d, w %2d, F %d, 2nd: x %4d, y %4d, z %3d, w %2d, F %d, dx %4d, dy %4d\n", */
+                               /*      x, y, z, w, finger, */
+                               /*      x2, y2, z2, w2, finger2, */
+                               /*      dx, dy); */
+
+                               base = 2;
+                               for (f = 0; f < 2; f++) {
+                                       uint32_t flip_flag = SYNAPTICS_FLIP_X;
+                                       for (a = 0; a < 2; a++) {
+                                               int p = buf[base + 1];
+                                               p |= (uint16_t)(buf[base] & 0x1f) << 8;
+                                               if (ts->flags & flip_flag)
+                                                       p = ts->max[a] - p;
+                                               if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) {
+                                                       if (ts->snap_state[f][a]) {
+                                                               if (p <= ts->snap_down_off[a])
+                                                                       p = ts->snap_down[a];
+                                                               else if (p >= ts->snap_up_off[a])
+                                                                       p = ts->snap_up[a];
+                                                               else
+                                                                       ts->snap_state[f][a] = 0;
+                                                       } else {
+                                                               if (p <= ts->snap_down_on[a]) {
+                                                                       p = ts->snap_down[a];
+                                                                       ts->snap_state[f][a] = 1;
+                                                               } else if (p >= ts->snap_up_on[a]) {
+                                                                       p = ts->snap_up[a];
+                                                                       ts->snap_state[f][a] = 1;
+                                                               }
+                                                       }
+                                               }
+                                               pos[f][a] = p;
+                                               base += 2;
+                                               flip_flag <<= 1;
+                                       }
+                                       base += 2;
+                                       if (ts->flags & SYNAPTICS_SWAP_XY)
+                                               swap(pos[f][0], pos[f][1]);
+                               }
+                               if (z) {
+                                       input_report_abs(ts->input_dev, ABS_X, pos[0][0]);
+                                       input_report_abs(ts->input_dev, ABS_Y, pos[0][1]);
+                               }
+                               input_report_abs(ts->input_dev, ABS_PRESSURE, z);
+                               input_report_abs(ts->input_dev, ABS_TOOL_WIDTH, w);
+                               input_report_key(ts->input_dev, BTN_TOUCH, finger);
+                               finger2_pressed = finger > 1 && finger != 7;
+                               input_report_key(ts->input_dev, BTN_2, finger2_pressed);
+                               if (finger2_pressed) {
+                                       input_report_abs(ts->input_dev, ABS_HAT0X, pos[1][0]);
+                                       input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]);
+                               }
+
+                               if (!finger)
+                                       z = 0;
+                               input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, z);
+                               input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w);
+                               input_report_abs(ts->input_dev, ABS_MT_POSITION_X, pos[0][0]);
+                               input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, pos[0][1]);
+                               input_mt_sync(ts->input_dev);
+                               if (finger2_pressed) {
+                                       input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, z);
+                                       input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w);
+                                       input_report_abs(ts->input_dev, ABS_MT_POSITION_X, pos[1][0]);
+                                       input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, pos[1][1]);
+                                       input_mt_sync(ts->input_dev);
+                               } else if (ts->reported_finger_count > 1) {
+                                       input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
+                                       input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0);
+                                       input_mt_sync(ts->input_dev);
+                               }
+                               ts->reported_finger_count = finger;
+                               input_sync(ts->input_dev);
+                       }
+               }
+       }
+       if (ts->use_irq)
+               enable_irq(ts->client->irq);
+}
+
+static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
+{
+       struct synaptics_ts_data *ts = container_of(timer, struct synaptics_ts_data, timer);
+       /* printk("synaptics_ts_timer_func\n"); */
+
+       queue_work(synaptics_wq, &ts->work);
+
+       hrtimer_start(&ts->timer, ktime_set(0, 12500000), HRTIMER_MODE_REL);
+       return HRTIMER_NORESTART;
+}
+
+static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
+{
+       struct synaptics_ts_data *ts = dev_id;
+
+       /* printk("synaptics_ts_irq_handler\n"); */
+       disable_irq_nosync(ts->client->irq);
+       queue_work(synaptics_wq, &ts->work);
+       return IRQ_HANDLED;
+}
+
+static int synaptics_ts_probe(
+       struct i2c_client *client, const struct i2c_device_id *id)
+{
+       struct synaptics_ts_data *ts;
+       uint8_t buf0[4];
+       uint8_t buf1[8];
+       struct i2c_msg msg[2];
+       int ret = 0;
+       uint16_t max_x, max_y;
+       int fuzz_x, fuzz_y, fuzz_p, fuzz_w;
+       struct synaptics_i2c_rmi_platform_data *pdata;
+       unsigned long irqflags;
+       int inactive_area_left;
+       int inactive_area_right;
+       int inactive_area_top;
+       int inactive_area_bottom;
+       int snap_left_on;
+       int snap_left_off;
+       int snap_right_on;
+       int snap_right_off;
+       int snap_top_on;
+       int snap_top_off;
+       int snap_bottom_on;
+       int snap_bottom_off;
+       uint32_t panel_version;
+
+       if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+               printk(KERN_ERR "synaptics_ts_probe: need I2C_FUNC_I2C\n");
+               ret = -ENODEV;
+               goto err_check_functionality_failed;
+       }
+
+       ts = kzalloc(sizeof(*ts), GFP_KERNEL);
+       if (ts == NULL) {
+               ret = -ENOMEM;
+               goto err_alloc_data_failed;
+       }
+       INIT_WORK(&ts->work, synaptics_ts_work_func);
+       ts->client = client;
+       i2c_set_clientdata(client, ts);
+       pdata = client->dev.platform_data;
+       if (pdata)
+               ts->power = pdata->power;
+       if (ts->power) {
+               ret = ts->power(1);
+               if (ret < 0) {
+                       printk(KERN_ERR "synaptics_ts_probe power on failed\n");
+                       goto err_power_failed;
+               }
+       }
+
+       ret = i2c_smbus_write_byte_data(ts->client, 0xf4, 0x01); /* device command = reset */
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_write_byte_data failed\n");
+               /* fail? */
+       }
+       {
+               int retry = 10;
+               while (retry-- > 0) {
+                       ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
+                       if (ret >= 0)
+                               break;
+                       msleep(100);
+               }
+       }
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
+               goto err_detect_failed;
+       }
+       printk(KERN_INFO "synaptics_ts_probe: Product Major Version %x\n", ret);
+       panel_version = ret << 8;
+       ret = i2c_smbus_read_byte_data(ts->client, 0xe5);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
+               goto err_detect_failed;
+       }
+       printk(KERN_INFO "synaptics_ts_probe: Product Minor Version %x\n", ret);
+       panel_version |= ret;
+
+       ret = i2c_smbus_read_byte_data(ts->client, 0xe3);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
+               goto err_detect_failed;
+       }
+       printk(KERN_INFO "synaptics_ts_probe: product property %x\n", ret);
+
+       if (pdata) {
+               while (pdata->version > panel_version)
+                       pdata++;
+               ts->flags = pdata->flags;
+               ts->sensitivity_adjust = pdata->sensitivity_adjust;
+               irqflags = pdata->irqflags;
+               inactive_area_left = pdata->inactive_left;
+               inactive_area_right = pdata->inactive_right;
+               inactive_area_top = pdata->inactive_top;
+               inactive_area_bottom = pdata->inactive_bottom;
+               snap_left_on = pdata->snap_left_on;
+               snap_left_off = pdata->snap_left_off;
+               snap_right_on = pdata->snap_right_on;
+               snap_right_off = pdata->snap_right_off;
+               snap_top_on = pdata->snap_top_on;
+               snap_top_off = pdata->snap_top_off;
+               snap_bottom_on = pdata->snap_bottom_on;
+               snap_bottom_off = pdata->snap_bottom_off;
+               fuzz_x = pdata->fuzz_x;
+               fuzz_y = pdata->fuzz_y;
+               fuzz_p = pdata->fuzz_p;
+               fuzz_w = pdata->fuzz_w;
+       } else {
+               irqflags = 0;
+               inactive_area_left = 0;
+               inactive_area_right = 0;
+               inactive_area_top = 0;
+               inactive_area_bottom = 0;
+               snap_left_on = 0;
+               snap_left_off = 0;
+               snap_right_on = 0;
+               snap_right_off = 0;
+               snap_top_on = 0;
+               snap_top_off = 0;
+               snap_bottom_on = 0;
+               snap_bottom_off = 0;
+               fuzz_x = 0;
+               fuzz_y = 0;
+               fuzz_p = 0;
+               fuzz_w = 0;
+       }
+
+       ret = i2c_smbus_read_byte_data(ts->client, 0xf0);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
+               goto err_detect_failed;
+       }
+       printk(KERN_INFO "synaptics_ts_probe: device control %x\n", ret);
+
+       ret = i2c_smbus_read_byte_data(ts->client, 0xf1);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
+               goto err_detect_failed;
+       }
+       printk(KERN_INFO "synaptics_ts_probe: interrupt enable %x\n", ret);
+
+       ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0); /* disable interrupt */
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_write_byte_data failed\n");
+               goto err_detect_failed;
+       }
+
+       msg[0].addr = ts->client->addr;
+       msg[0].flags = 0;
+       msg[0].len = 1;
+       msg[0].buf = buf0;
+       buf0[0] = 0xe0;
+       msg[1].addr = ts->client->addr;
+       msg[1].flags = I2C_M_RD;
+       msg[1].len = 8;
+       msg[1].buf = buf1;
+       ret = i2c_transfer(ts->client->adapter, msg, 2);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_transfer failed\n");
+               goto err_detect_failed;
+       }
+       printk(KERN_INFO "synaptics_ts_probe: 0xe0: %x %x %x %x %x %x %x %x\n",
+              buf1[0], buf1[1], buf1[2], buf1[3],
+              buf1[4], buf1[5], buf1[6], buf1[7]);
+
+       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10); /* page select = 0x10 */
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
+               goto err_detect_failed;
+       }
+       ret = i2c_smbus_read_word_data(ts->client, 0x02);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
+               goto err_detect_failed;
+       }
+       ts->has_relative_report = !(ret & 0x100);
+       printk(KERN_INFO "synaptics_ts_probe: Sensor properties %x\n", ret);
+       ret = i2c_smbus_read_word_data(ts->client, 0x04);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
+               goto err_detect_failed;
+       }
+       ts->max[0] = max_x = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
+       ret = i2c_smbus_read_word_data(ts->client, 0x06);
+       if (ret < 0) {
+               printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
+               goto err_detect_failed;
+       }
+       ts->max[1] = max_y = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
+       if (ts->flags & SYNAPTICS_SWAP_XY)
+               swap(max_x, max_y);
+
+       ret = synaptics_init_panel(ts); /* will also switch back to page 0x04 */
+       if (ret < 0) {
+               printk(KERN_ERR "synaptics_init_panel failed\n");
+               goto err_detect_failed;
+       }
+
+       ts->input_dev = input_allocate_device();
+       if (ts->input_dev == NULL) {
+               ret = -ENOMEM;
+               printk(KERN_ERR "synaptics_ts_probe: Failed to allocate input device\n");
+               goto err_input_dev_alloc_failed;
+       }
+       ts->input_dev->name = "synaptics-rmi-touchscreen";
+       set_bit(EV_SYN, ts->input_dev->evbit);
+       set_bit(EV_KEY, ts->input_dev->evbit);
+       set_bit(BTN_TOUCH, ts->input_dev->keybit);
+       set_bit(BTN_2, ts->input_dev->keybit);
+       set_bit(EV_ABS, ts->input_dev->evbit);
+       inactive_area_left = inactive_area_left * max_x / 0x10000;
+       inactive_area_right = inactive_area_right * max_x / 0x10000;
+       inactive_area_top = inactive_area_top * max_y / 0x10000;
+       inactive_area_bottom = inactive_area_bottom * max_y / 0x10000;
+       snap_left_on = snap_left_on * max_x / 0x10000;
+       snap_left_off = snap_left_off * max_x / 0x10000;
+       snap_right_on = snap_right_on * max_x / 0x10000;
+       snap_right_off = snap_right_off * max_x / 0x10000;
+       snap_top_on = snap_top_on * max_y / 0x10000;
+       snap_top_off = snap_top_off * max_y / 0x10000;
+       snap_bottom_on = snap_bottom_on * max_y / 0x10000;
+       snap_bottom_off = snap_bottom_off * max_y / 0x10000;
+       fuzz_x = fuzz_x * max_x / 0x10000;
+       fuzz_y = fuzz_y * max_y / 0x10000;
+       ts->snap_down[!!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_left;
+       ts->snap_up[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x + inactive_area_right;
+       ts->snap_down[!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_top;
+       ts->snap_up[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y + inactive_area_bottom;
+       ts->snap_down_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_on;
+       ts->snap_down_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_off;
+       ts->snap_up_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_on;
+       ts->snap_up_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_off;
+       ts->snap_down_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_on;
+       ts->snap_down_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_off;
+       ts->snap_up_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_on;
+       ts->snap_up_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_off;
+       printk(KERN_INFO "synaptics_ts_probe: max_x %d, max_y %d\n", max_x, max_y);
+       printk(KERN_INFO "synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
+              inactive_area_left, inactive_area_right,
+              inactive_area_top, inactive_area_bottom);
+       printk(KERN_INFO "synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
+              snap_left_on, snap_left_off, snap_right_on, snap_right_off,
+              snap_top_on, snap_top_off, snap_bottom_on, snap_bottom_off);
+       input_set_abs_params(ts->input_dev, ABS_X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
+       input_set_abs_params(ts->input_dev, ABS_Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
+       input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0);
+       input_set_abs_params(ts->input_dev, ABS_TOOL_WIDTH, 0, 15, fuzz_w, 0);
+       input_set_abs_params(ts->input_dev, ABS_HAT0X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
+       input_set_abs_params(ts->input_dev, ABS_HAT0Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
+       input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
+       input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
+       input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, fuzz_p, 0);
+       input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 15, fuzz_w, 0);
+       /* ts->input_dev->name = ts->keypad_info->name; */
+       ret = input_register_device(ts->input_dev);
+       if (ret) {
+               printk(KERN_ERR "synaptics_ts_probe: Unable to register %s input device\n", ts->input_dev->name);
+               goto err_input_register_device_failed;
+       }
+       if (client->irq) {
+               ret = request_irq(client->irq, synaptics_ts_irq_handler, irqflags, client->name, ts);
+               if (ret == 0) {
+                       ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0x01); /* enable abs int */
+                       if (ret)
+                               free_irq(client->irq, ts);
+               }
+               if (ret == 0)
+                       ts->use_irq = 1;
+               else
+                       dev_err(&client->dev, "request_irq failed\n");
+       }
+       if (!ts->use_irq) {
+               hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+               ts->timer.function = synaptics_ts_timer_func;
+               hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
+       }
+#ifdef CONFIG_HAS_EARLYSUSPEND
+       ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+       ts->early_suspend.suspend = synaptics_ts_early_suspend;
+       ts->early_suspend.resume = synaptics_ts_late_resume;
+       register_early_suspend(&ts->early_suspend);
+#endif
+
+       printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
+
+       return 0;
+
+err_input_register_device_failed:
+       input_free_device(ts->input_dev);
+
+err_input_dev_alloc_failed:
+err_detect_failed:
+err_power_failed:
+       kfree(ts);
+err_alloc_data_failed:
+err_check_functionality_failed:
+       return ret;
+}
+
+static int synaptics_ts_remove(struct i2c_client *client)
+{
+       struct synaptics_ts_data *ts = i2c_get_clientdata(client);
+       unregister_early_suspend(&ts->early_suspend);
+       if (ts->use_irq)
+               free_irq(client->irq, ts);
+       else
+               hrtimer_cancel(&ts->timer);
+       input_unregister_device(ts->input_dev);
+       kfree(ts);
+       return 0;
+}
+
+static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+       int ret;
+       struct synaptics_ts_data *ts = i2c_get_clientdata(client);
+
+       if (ts->use_irq)
+               disable_irq(client->irq);
+       else
+               hrtimer_cancel(&ts->timer);
+       ret = cancel_work_sync(&ts->work);
+       if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
+               enable_irq(client->irq);
+       ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0); /* disable interrupt */
+       if (ret < 0)
+               printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n");
+
+       ret = i2c_smbus_write_byte_data(client, 0xf0, 0x86); /* deep sleep */
+       if (ret < 0)
+               printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n");
+       if (ts->power) {
+               ret = ts->power(0);
+               if (ret < 0)
+                       printk(KERN_ERR "synaptics_ts_resume power off failed\n");
+       }
+       return 0;
+}
+
+static int synaptics_ts_resume(struct i2c_client *client)
+{
+       int ret;
+       struct synaptics_ts_data *ts = i2c_get_clientdata(client);
+
+       if (ts->power) {
+               ret = ts->power(1);
+               if (ret < 0)
+                       printk(KERN_ERR "synaptics_ts_resume power on failed\n");
+       }
+
+       synaptics_init_panel(ts);
+
+       if (ts->use_irq)
+               enable_irq(client->irq);
+
+       if (!ts->use_irq)
+               hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
+       else
+               i2c_smbus_write_byte_data(ts->client, 0xf1, 0x01); /* enable abs int */
+
+       return 0;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void synaptics_ts_early_suspend(struct early_suspend *h)
+{
+       struct synaptics_ts_data *ts;
+       ts = container_of(h, struct synaptics_ts_data, early_suspend);
+       synaptics_ts_suspend(ts->client, PMSG_SUSPEND);
+}
+
+static void synaptics_ts_late_resume(struct early_suspend *h)
+{
+       struct synaptics_ts_data *ts;
+       ts = container_of(h, struct synaptics_ts_data, early_suspend);
+       synaptics_ts_resume(ts->client);
+}
+#endif
+
+static const struct i2c_device_id synaptics_ts_id[] = {
+       { SYNAPTICS_I2C_RMI_NAME, 0 },
+       { }
+};
+
+static struct i2c_driver synaptics_ts_driver = {
+       .probe          = synaptics_ts_probe,
+       .remove         = synaptics_ts_remove,
+#ifndef CONFIG_HAS_EARLYSUSPEND
+       .suspend        = synaptics_ts_suspend,
+       .resume         = synaptics_ts_resume,
+#endif
+       .id_table       = synaptics_ts_id,
+       .driver = {
+               .name   = SYNAPTICS_I2C_RMI_NAME,
+       },
+};
+
+static int __devinit synaptics_ts_init(void)
+{
+       synaptics_wq = create_singlethread_workqueue("synaptics_wq");
+       if (!synaptics_wq)
+               return -ENOMEM;
+       return i2c_add_driver(&synaptics_ts_driver);
+}
+
+static void __exit synaptics_ts_exit(void)
+{
+       i2c_del_driver(&synaptics_ts_driver);
+       if (synaptics_wq)
+               destroy_workqueue(synaptics_wq);
+}
+
+module_init(synaptics_ts_init);
+module_exit(synaptics_ts_exit);
+
+MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/synaptics_i2c_rmi.h b/include/linux/synaptics_i2c_rmi.h
new file mode 100644 (file)
index 0000000..5539cc5
--- /dev/null
@@ -0,0 +1,55 @@
+/*
+ * include/linux/synaptics_i2c_rmi.h - platform data structure for f75375s sensor
+ *
+ * Copyright (C) 2008 Google, 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.
+ *
+ */
+
+#ifndef _LINUX_SYNAPTICS_I2C_RMI_H
+#define _LINUX_SYNAPTICS_I2C_RMI_H
+
+#define SYNAPTICS_I2C_RMI_NAME "synaptics-rmi-ts"
+
+enum {
+       SYNAPTICS_FLIP_X = 1UL << 0,
+       SYNAPTICS_FLIP_Y = 1UL << 1,
+       SYNAPTICS_SWAP_XY = 1UL << 2,
+       SYNAPTICS_SNAP_TO_INACTIVE_EDGE = 1UL << 3,
+};
+
+struct synaptics_i2c_rmi_platform_data {
+       uint32_t version;       /* Use this entry for panels with */
+                               /* (major << 8 | minor) version or above. */
+                               /* If non-zero another array entry follows */
+       int (*power)(int on);   /* Only valid in first array entry */
+       uint32_t flags;
+       unsigned long irqflags;
+       uint32_t inactive_left; /* 0x10000 = screen width */
+       uint32_t inactive_right; /* 0x10000 = screen width */
+       uint32_t inactive_top; /* 0x10000 = screen height */
+       uint32_t inactive_bottom; /* 0x10000 = screen height */
+       uint32_t snap_left_on; /* 0x10000 = screen width */
+       uint32_t snap_left_off; /* 0x10000 = screen width */
+       uint32_t snap_right_on; /* 0x10000 = screen width */
+       uint32_t snap_right_off; /* 0x10000 = screen width */
+       uint32_t snap_top_on; /* 0x10000 = screen height */
+       uint32_t snap_top_off; /* 0x10000 = screen height */
+       uint32_t snap_bottom_on; /* 0x10000 = screen height */
+       uint32_t snap_bottom_off; /* 0x10000 = screen height */
+       uint32_t fuzz_x; /* 0x10000 = screen width */
+       uint32_t fuzz_y; /* 0x10000 = screen height */
+       int fuzz_p;
+       int fuzz_w;
+       int8_t sensitivity_adjust;
+};
+
+#endif /* _LINUX_SYNAPTICS_I2C_RMI_H */