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
:
538 i2c_set_clientdata(client
, NULL
);
540 err_alloc_data_failed
:
541 err_check_functionality_failed
:
545 static int synaptics_ts_remove(struct i2c_client
*client
)
547 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
548 #ifdef CONFIG_HAS_EARLYSUSPEND
549 unregister_early_suspend(&ts
->early_suspend
);
552 free_irq(client
->irq
, ts
);
554 hrtimer_cancel(&ts
->timer
);
555 input_unregister_device(ts
->input_dev
);
556 i2c_set_clientdata(client
, NULL
);
562 static int synaptics_ts_suspend(struct i2c_client
*client
, pm_message_t mesg
)
565 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
568 disable_irq(client
->irq
);
570 hrtimer_cancel(&ts
->timer
);
571 ret
= cancel_work_sync(&ts
->work
);
572 if (ret
&& ts
->use_irq
) /* if work was pending disable-count is now 2 */
573 enable_irq(client
->irq
);
574 i2c_set(ts
, 0xf1, 0, "disable interrupt");
575 i2c_set(ts
, 0xf0, 0x86, "deep sleep");
580 pr_err("synaptics_ts_suspend power off failed\n");
585 static int synaptics_ts_resume(struct i2c_client
*client
)
588 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
593 pr_err("synaptics_ts_resume power on failed\n");
596 synaptics_init_panel(ts
);
599 enable_irq(client
->irq
);
600 i2c_set(ts
, 0xf1, 0x01, "enable abs int");
602 hrtimer_start(&ts
->timer
, ktime_set(1, 0), HRTIMER_MODE_REL
);
607 #ifdef CONFIG_HAS_EARLYSUSPEND
608 static void synaptics_ts_early_suspend(struct early_suspend
*h
)
610 struct synaptics_ts_data
*ts
;
611 ts
= container_of(h
, struct synaptics_ts_data
, early_suspend
);
612 synaptics_ts_suspend(ts
->client
, PMSG_SUSPEND
);
615 static void synaptics_ts_late_resume(struct early_suspend
*h
)
617 struct synaptics_ts_data
*ts
;
618 ts
= container_of(h
, struct synaptics_ts_data
, early_suspend
);
619 synaptics_ts_resume(ts
->client
);
623 #define synaptics_ts_suspend NULL
624 #define synaptics_ts_resume NULL
629 static const struct i2c_device_id synaptics_ts_id
[] = {
630 { SYNAPTICS_I2C_RMI_NAME
, 0 },
634 static struct i2c_driver synaptics_ts_driver
= {
635 .probe
= synaptics_ts_probe
,
636 .remove
= synaptics_ts_remove
,
637 #ifndef CONFIG_HAS_EARLYSUSPEND
638 .suspend
= synaptics_ts_suspend
,
639 .resume
= synaptics_ts_resume
,
641 .id_table
= synaptics_ts_id
,
643 .name
= SYNAPTICS_I2C_RMI_NAME
,
647 static int __devinit
synaptics_ts_init(void)
649 synaptics_wq
= create_singlethread_workqueue("synaptics_wq");
652 return i2c_add_driver(&synaptics_ts_driver
);
655 static void __exit
synaptics_ts_exit(void)
657 i2c_del_driver(&synaptics_ts_driver
);
659 destroy_workqueue(synaptics_wq
);
662 module_init(synaptics_ts_init
);
663 module_exit(synaptics_ts_exit
);
665 MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
666 MODULE_LICENSE("GPL");
667 MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");