2 * Support for synaptics touchscreen.
4 * Copyright (C) 2007 Google, Inc.
5 * Author: Arve Hjønnevåg <arve@android.com>
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * http://www.synaptics.com/sites/default/files/511_000099_01F.pdf
19 #include <linux/module.h>
20 #include <linux/delay.h>
21 #include <linux/slab.h>
22 #ifdef CONFIG_HAS_EARLYSUSPEND
23 #include <linux/earlysuspend.h>
25 #include <linux/hrtimer.h>
26 #include <linux/i2c.h>
27 #include <linux/input.h>
28 #include <linux/interrupt.h>
30 #include <linux/platform_device.h>
31 #include "synaptics_i2c_rmi.h"
33 static struct workqueue_struct *synaptics_wq;
35 struct synaptics_ts_data {
37 struct i2c_client *client;
38 struct input_dev *input_dev;
41 struct work_struct work;
52 #ifdef CONFIG_HAS_EARLYSUSPEND
53 struct early_suspend early_suspend;
57 static int i2c_set(struct synaptics_ts_data *ts, u8 reg, u8 val, char *msg)
59 int ret = i2c_smbus_write_byte_data(ts->client, reg, val);
61 pr_err("i2c_smbus_write_byte_data failed (%s)\n", msg);
65 static int i2c_read(struct synaptics_ts_data *ts, u8 reg, char *msg)
67 int ret = i2c_smbus_read_byte_data(ts->client, reg);
69 pr_err("i2c_smbus_read_byte_data failed (%s)\n", msg);
72 #ifdef CONFIG_HAS_EARLYSUSPEND
73 static void synaptics_ts_early_suspend(struct early_suspend *h);
74 static void synaptics_ts_late_resume(struct early_suspend *h);
77 static int synaptics_init_panel(struct synaptics_ts_data *ts)
81 ret = i2c_set(ts, 0xff, 0x10, "set page select");
83 ret = i2c_set(ts, 0x41, 0x04, "set No Clip Z");
85 ret = i2c_set(ts, 0xff, 0x04, "fallback page select");
86 ret = i2c_set(ts, 0xf0, 0x81, "select 80 reports per second");
90 static void decode_report(struct synaptics_ts_data *ts, u8 *buf)
93 * This sensor sends two 6-byte absolute finger reports, an optional
94 * 2-byte relative report followed by a status byte. This function
95 * reads the two finger reports and transforms the coordinates
96 * according the platform data so they can be aligned with the lcd
97 * behind the touchscreen. Typically we flip the y-axis since the
98 * sensor uses the bottom left corner as the origin, but if the sensor
99 * is mounted upside down the platform data will request that the
100 * x-axis should be flipped instead. The snap to inactive edge border
101 * are used to allow tapping the edges of the screen on the G1. The
102 * active area of the touchscreen is smaller than the lcd. When the
103 * finger gets close the edge of the screen we snap it to the
104 * edge. This allows ui elements at the edge of the screen to be hit,
105 * and it prevents hitting ui elements that are not at the edge of the
106 * screen when the finger is touching the edge.
113 int finger = buf[0] & 7;
116 for (f = 0; f < 2; f++) {
117 u32 flip_flag = SYNAPTICS_FLIP_X;
118 for (a = 0; a < 2; a++) {
119 int p = buf[base + 1];
120 p |= (u16)(buf[base] & 0x1f) << 8;
121 if (ts->flags & flip_flag)
123 if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) {
124 if (ts->snap_state[f][a]) {
125 if (p <= ts->snap_down_off[a])
126 p = ts->snap_down[a];
127 else if (p >= ts->snap_up_off[a])
130 ts->snap_state[f][a] = 0;
132 if (p <= ts->snap_down_on[a]) {
133 p = ts->snap_down[a];
134 ts->snap_state[f][a] = 1;
135 } else if (p >= ts->snap_up_on[a]) {
137 ts->snap_state[f][a] = 1;
146 if (ts->flags & SYNAPTICS_SWAP_XY)
147 swap(pos[f][0], pos[f][1]);
150 input_report_abs(ts->input_dev, ABS_X, pos[0][0]);
151 input_report_abs(ts->input_dev, ABS_Y, pos[0][1]);
153 input_report_abs(ts->input_dev, ABS_PRESSURE, z);
154 input_report_abs(ts->input_dev, ABS_TOOL_WIDTH, w);
155 input_report_key(ts->input_dev, BTN_TOUCH, finger);
156 finger2_pressed = finger > 1 && finger != 7;
157 input_report_key(ts->input_dev, BTN_2, finger2_pressed);
158 if (finger2_pressed) {
159 input_report_abs(ts->input_dev, ABS_HAT0X, pos[1][0]);
160 input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]);
162 input_sync(ts->input_dev);
165 static void synaptics_ts_work_func(struct work_struct *work)
170 struct i2c_msg msg[2];
173 struct synaptics_ts_data *ts =
174 container_of(work, struct synaptics_ts_data, work);
176 msg[0].addr = ts->client->addr;
179 msg[0].buf = &start_reg;
180 msg[1].addr = ts->client->addr;
181 msg[1].flags = I2C_M_RD;
182 msg[1].len = sizeof(buf);
185 for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
186 ret = i2c_transfer(ts->client->adapter, msg, 2);
188 pr_err("ts_work: i2c_transfer failed\n");
192 if ((buf[14] & 0xc0) != 0x40) {
193 pr_warning("synaptics_ts_work_func:"
194 " bad read %x %x %x %x %x %x %x %x %x"
195 " %x %x %x %x %x %x, ret %d\n",
196 buf[0], buf[1], buf[2], buf[3],
197 buf[4], buf[5], buf[6], buf[7],
198 buf[8], buf[9], buf[10], buf[11],
199 buf[12], buf[13], buf[14], ret);
201 synaptics_init_panel(ts);
206 if ((buf[14] & 1) == 0)
209 decode_report(ts, buf);
212 enable_irq(ts->client->irq);
215 static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
217 struct synaptics_ts_data *ts =
218 container_of(timer, struct synaptics_ts_data, timer);
220 queue_work(synaptics_wq, &ts->work);
222 hrtimer_start(&ts->timer, ktime_set(0, 12500000), HRTIMER_MODE_REL);
223 return HRTIMER_NORESTART;
226 static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
228 struct synaptics_ts_data *ts = dev_id;
230 disable_irq_nosync(ts->client->irq);
231 queue_work(synaptics_wq, &ts->work);
235 static int detect(struct synaptics_ts_data *ts, u32 *panel_version)
240 ret = i2c_set(ts, 0xf4, 0x01, "reset device");
242 while (retry-- > 0) {
243 ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
249 pr_err("i2c_smbus_read_byte_data failed\n");
253 *panel_version = ret << 8;
254 ret = i2c_read(ts, 0xe5, "product minor");
257 *panel_version |= ret;
259 ret = i2c_read(ts, 0xe3, "property");
263 pr_info("synaptics: version %x, product property %x\n",
264 *panel_version, ret);
268 static void compute_areas(struct synaptics_ts_data *ts,
269 struct synaptics_i2c_rmi_platform_data *pdata,
270 u16 max_x, u16 max_y)
272 int inactive_area_left;
273 int inactive_area_right;
274 int inactive_area_top;
275 int inactive_area_bottom;
288 int swapped = !!(ts->flags & SYNAPTICS_SWAP_XY);
290 inactive_area_left = pdata->inactive_left;
291 inactive_area_right = pdata->inactive_right;
292 inactive_area_top = pdata->inactive_top;
293 inactive_area_bottom = pdata->inactive_bottom;
294 snap_left_on = pdata->snap_left_on;
295 snap_left_off = pdata->snap_left_off;
296 snap_right_on = pdata->snap_right_on;
297 snap_right_off = pdata->snap_right_off;
298 snap_top_on = pdata->snap_top_on;
299 snap_top_off = pdata->snap_top_off;
300 snap_bottom_on = pdata->snap_bottom_on;
301 snap_bottom_off = pdata->snap_bottom_off;
302 fuzz_x = pdata->fuzz_x;
303 fuzz_y = pdata->fuzz_y;
304 fuzz_p = pdata->fuzz_p;
305 fuzz_w = pdata->fuzz_w;
307 inactive_area_left = inactive_area_left * max_x / 0x10000;
308 inactive_area_right = inactive_area_right * max_x / 0x10000;
309 inactive_area_top = inactive_area_top * max_y / 0x10000;
310 inactive_area_bottom = inactive_area_bottom * max_y / 0x10000;
311 snap_left_on = snap_left_on * max_x / 0x10000;
312 snap_left_off = snap_left_off * max_x / 0x10000;
313 snap_right_on = snap_right_on * max_x / 0x10000;
314 snap_right_off = snap_right_off * max_x / 0x10000;
315 snap_top_on = snap_top_on * max_y / 0x10000;
316 snap_top_off = snap_top_off * max_y / 0x10000;
317 snap_bottom_on = snap_bottom_on * max_y / 0x10000;
318 snap_bottom_off = snap_bottom_off * max_y / 0x10000;
319 fuzz_x = fuzz_x * max_x / 0x10000;
320 fuzz_y = fuzz_y * max_y / 0x10000;
323 ts->snap_down[swapped] = -inactive_area_left;
324 ts->snap_up[swapped] = max_x + inactive_area_right;
325 ts->snap_down[!swapped] = -inactive_area_top;
326 ts->snap_up[!swapped] = max_y + inactive_area_bottom;
327 ts->snap_down_on[swapped] = snap_left_on;
328 ts->snap_down_off[swapped] = snap_left_off;
329 ts->snap_up_on[swapped] = max_x - snap_right_on;
330 ts->snap_up_off[swapped] = max_x - snap_right_off;
331 ts->snap_down_on[!swapped] = snap_top_on;
332 ts->snap_down_off[!swapped] = snap_top_off;
333 ts->snap_up_on[!swapped] = max_y - snap_bottom_on;
334 ts->snap_up_off[!swapped] = max_y - snap_bottom_off;
335 pr_info("synaptics_ts_probe: max_x %d, max_y %d\n", max_x, max_y);
336 pr_info("synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
337 inactive_area_left, inactive_area_right,
338 inactive_area_top, inactive_area_bottom);
339 pr_info("synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
340 snap_left_on, snap_left_off, snap_right_on, snap_right_off,
341 snap_top_on, snap_top_off, snap_bottom_on, snap_bottom_off);
343 input_set_abs_params(ts->input_dev, ABS_X,
344 -inactive_area_left, max_x + inactive_area_right,
346 input_set_abs_params(ts->input_dev, ABS_Y,
347 -inactive_area_top, max_y + inactive_area_bottom,
349 input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0);
350 input_set_abs_params(ts->input_dev, ABS_TOOL_WIDTH, 0, 15, fuzz_w, 0);
351 input_set_abs_params(ts->input_dev, ABS_HAT0X, -inactive_area_left,
352 max_x + inactive_area_right, fuzz_x, 0);
353 input_set_abs_params(ts->input_dev, ABS_HAT0Y, -inactive_area_top,
354 max_y + inactive_area_bottom, fuzz_y, 0);
357 static struct synaptics_i2c_rmi_platform_data fake_pdata;
359 static int __devinit synaptics_ts_probe(
360 struct i2c_client *client, const struct i2c_device_id *id)
362 struct synaptics_ts_data *ts;
365 struct i2c_msg msg[2];
367 struct synaptics_i2c_rmi_platform_data *pdata;
368 u32 panel_version = 0;
371 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
372 pr_err("synaptics_ts_probe: need I2C_FUNC_I2C\n");
374 goto err_check_functionality_failed;
377 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
378 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
380 goto err_check_functionality_failed;
383 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
384 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
386 goto err_check_functionality_failed;
389 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
392 goto err_alloc_data_failed;
394 INIT_WORK(&ts->work, synaptics_ts_work_func);
396 i2c_set_clientdata(client, ts);
397 pdata = client->dev.platform_data;
399 ts->power = pdata->power;
406 pr_err("synaptics_ts_probe power on failed\n");
407 goto err_power_failed;
411 ret = detect(ts, &panel_version);
413 goto err_detect_failed;
415 while (pdata->version > panel_version)
417 ts->flags = pdata->flags;
419 ret = i2c_read(ts, 0xf0, "device control");
421 goto err_detect_failed;
422 pr_info("synaptics: device control %x\n", ret);
424 ret = i2c_read(ts, 0xf1, "interrupt enable");
426 goto err_detect_failed;
427 pr_info("synaptics_ts_probe: interrupt enable %x\n", ret);
429 ret = i2c_set(ts, 0xf1, 0, "disable interrupt");
431 goto err_detect_failed;
433 msg[0].addr = ts->client->addr;
438 msg[1].addr = ts->client->addr;
439 msg[1].flags = I2C_M_RD;
442 ret = i2c_transfer(ts->client->adapter, msg, 2);
444 pr_err("i2c_transfer failed\n");
445 goto err_detect_failed;
447 pr_info("synaptics_ts_probe: 0xe0: %x %x %x %x %x %x %x %x\n",
448 buf1[0], buf1[1], buf1[2], buf1[3],
449 buf1[4], buf1[5], buf1[6], buf1[7]);
451 ret = i2c_set(ts, 0xff, 0x10, "page select = 0x10");
453 goto err_detect_failed;
455 ret = i2c_smbus_read_word_data(ts->client, 0x04);
457 pr_err("i2c_smbus_read_word_data failed\n");
458 goto err_detect_failed;
460 ts->max[0] = max_x = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
461 ret = i2c_smbus_read_word_data(ts->client, 0x06);
463 pr_err("i2c_smbus_read_word_data failed\n");
464 goto err_detect_failed;
466 ts->max[1] = max_y = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
467 if (ts->flags & SYNAPTICS_SWAP_XY)
470 /* will also switch back to page 0x04 */
471 ret = synaptics_init_panel(ts);
473 pr_err("synaptics_init_panel failed\n");
474 goto err_detect_failed;
477 ts->input_dev = input_allocate_device();
478 if (ts->input_dev == NULL) {
480 pr_err("synaptics: Failed to allocate input device\n");
481 goto err_input_dev_alloc_failed;
483 ts->input_dev->name = "synaptics-rmi-touchscreen";
484 ts->input_dev->phys = "msm/input0";
485 ts->input_dev->id.bustype = BUS_I2C;
487 __set_bit(EV_SYN, ts->input_dev->evbit);
488 __set_bit(EV_KEY, ts->input_dev->evbit);
489 __set_bit(BTN_TOUCH, ts->input_dev->keybit);
490 __set_bit(BTN_2, ts->input_dev->keybit);
491 __set_bit(EV_ABS, ts->input_dev->evbit);
493 compute_areas(ts, pdata, max_x, max_y);
496 ret = input_register_device(ts->input_dev);
498 pr_err("synaptics: Unable to register %s input device\n",
499 ts->input_dev->name);
500 goto err_input_register_device_failed;
503 ret = request_irq(client->irq, synaptics_ts_irq_handler,
504 0, client->name, ts);
506 ret = i2c_set(ts, 0xf1, 0x01, "enable abs int");
508 free_irq(client->irq, ts);
513 dev_err(&client->dev, "request_irq failed\n");
516 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
517 ts->timer.function = synaptics_ts_timer_func;
518 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
520 #ifdef CONFIG_HAS_EARLYSUSPEND
521 ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
522 ts->early_suspend.suspend = synaptics_ts_early_suspend;
523 ts->early_suspend.resume = synaptics_ts_late_resume;
524 register_early_suspend(&ts->early_suspend);
527 pr_info("synaptics: Start touchscreen %s in %s mode\n",
528 ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
532 err_input_register_device_failed:
533 input_free_device(ts->input_dev);
535 err_input_dev_alloc_failed:
539 err_alloc_data_failed:
540 err_check_functionality_failed:
544 static int synaptics_ts_remove(struct i2c_client *client)
546 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
547 #ifdef CONFIG_HAS_EARLYSUSPEND
548 unregister_early_suspend(&ts->early_suspend);
551 free_irq(client->irq, ts);
553 hrtimer_cancel(&ts->timer);
554 input_unregister_device(ts->input_dev);
560 static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
563 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
566 disable_irq(client->irq);
568 hrtimer_cancel(&ts->timer);
569 ret = cancel_work_sync(&ts->work);
570 if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
571 enable_irq(client->irq);
572 i2c_set(ts, 0xf1, 0, "disable interrupt");
573 i2c_set(ts, 0xf0, 0x86, "deep sleep");
578 pr_err("synaptics_ts_suspend power off failed\n");
583 static int synaptics_ts_resume(struct i2c_client *client)
586 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
591 pr_err("synaptics_ts_resume power on failed\n");
594 synaptics_init_panel(ts);
597 enable_irq(client->irq);
598 i2c_set(ts, 0xf1, 0x01, "enable abs int");
600 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
605 #ifdef CONFIG_HAS_EARLYSUSPEND
606 static void synaptics_ts_early_suspend(struct early_suspend *h)
608 struct synaptics_ts_data *ts;
609 ts = container_of(h, struct synaptics_ts_data, early_suspend);
610 synaptics_ts_suspend(ts->client, PMSG_SUSPEND);
613 static void synaptics_ts_late_resume(struct early_suspend *h)
615 struct synaptics_ts_data *ts;
616 ts = container_of(h, struct synaptics_ts_data, early_suspend);
617 synaptics_ts_resume(ts->client);
621 #define synaptics_ts_suspend NULL
622 #define synaptics_ts_resume NULL
627 static const struct i2c_device_id synaptics_ts_id[] = {
628 { SYNAPTICS_I2C_RMI_NAME, 0 },
632 static struct i2c_driver synaptics_ts_driver = {
633 .probe = synaptics_ts_probe,
634 .remove = synaptics_ts_remove,
635 #ifndef CONFIG_HAS_EARLYSUSPEND
636 .suspend = synaptics_ts_suspend,
637 .resume = synaptics_ts_resume,
639 .id_table = synaptics_ts_id,
641 .name = SYNAPTICS_I2C_RMI_NAME,
645 static int __devinit synaptics_ts_init(void)
647 synaptics_wq = create_singlethread_workqueue("synaptics_wq");
650 return i2c_add_driver(&synaptics_ts_driver);
653 static void __exit synaptics_ts_exit(void)
655 i2c_del_driver(&synaptics_ts_driver);
657 destroy_workqueue(synaptics_wq);
660 module_init(synaptics_ts_init);
661 module_exit(synaptics_ts_exit);
663 MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
664 MODULE_LICENSE("GPL");
665 MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");