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 #ifdef CONFIG_HAS_EARLYSUSPEND
22 #include <linux/earlysuspend.h>
24 #include <linux/hrtimer.h>
25 #include <linux/i2c.h>
26 #include <linux/input.h>
27 #include <linux/interrupt.h>
29 #include <linux/platform_device.h>
30 #include "synaptics_i2c_rmi.h"
32 static struct workqueue_struct
*synaptics_wq
;
34 struct synaptics_ts_data
{
36 struct i2c_client
*client
;
37 struct input_dev
*input_dev
;
40 struct work_struct work
;
51 #ifdef CONFIG_HAS_EARLYSUSPEND
52 struct early_suspend early_suspend
;
56 static int i2c_set(struct synaptics_ts_data
*ts
, u8 reg
, u8 val
, char *msg
)
58 int ret
= i2c_smbus_write_byte_data(ts
->client
, reg
, val
);
60 pr_err("i2c_smbus_write_byte_data failed (%s)\n", msg
);
64 static int i2c_read(struct synaptics_ts_data
*ts
, u8 reg
, char *msg
)
66 int ret
= i2c_smbus_read_byte_data(ts
->client
, reg
);
68 pr_err("i2c_smbus_read_byte_data failed (%s)\n", msg
);
71 #ifdef CONFIG_HAS_EARLYSUSPEND
72 static void synaptics_ts_early_suspend(struct early_suspend
*h
);
73 static void synaptics_ts_late_resume(struct early_suspend
*h
);
76 static int synaptics_init_panel(struct synaptics_ts_data
*ts
)
80 ret
= i2c_set(ts
, 0xff, 0x10, "set page select");
82 ret
= i2c_set(ts
, 0x41, 0x04, "set No Clip Z");
84 ret
= i2c_set(ts
, 0xff, 0x04, "fallback page select");
85 ret
= i2c_set(ts
, 0xf0, 0x81, "select 80 reports per second");
89 static void decode_report(struct synaptics_ts_data
*ts
, u8
*buf
)
92 * This sensor sends two 6-byte absolute finger reports, an optional
93 * 2-byte relative report followed by a status byte. This function
94 * reads the two finger reports and transforms the coordinates
95 * according the platform data so they can be aligned with the lcd
96 * behind the touchscreen. Typically we flip the y-axis since the
97 * sensor uses the bottom left corner as the origin, but if the sensor
98 * is mounted upside down the platform data will request that the
99 * x-axis should be flipped instead. The snap to inactive edge border
100 * are used to allow tapping the edges of the screen on the G1. The
101 * active area of the touchscreen is smaller than the lcd. When the
102 * finger gets close the edge of the screen we snap it to the
103 * edge. This allows ui elements at the edge of the screen to be hit,
104 * and it prevents hitting ui elements that are not at the edge of the
105 * screen when the finger is touching the edge.
112 int finger
= buf
[0] & 7;
115 for (f
= 0; f
< 2; f
++) {
116 u32 flip_flag
= SYNAPTICS_FLIP_X
;
117 for (a
= 0; a
< 2; a
++) {
118 int p
= buf
[base
+ 1];
119 p
|= (u16
)(buf
[base
] & 0x1f) << 8;
120 if (ts
->flags
& flip_flag
)
122 if (ts
->flags
& SYNAPTICS_SNAP_TO_INACTIVE_EDGE
) {
123 if (ts
->snap_state
[f
][a
]) {
124 if (p
<= ts
->snap_down_off
[a
])
125 p
= ts
->snap_down
[a
];
126 else if (p
>= ts
->snap_up_off
[a
])
129 ts
->snap_state
[f
][a
] = 0;
131 if (p
<= ts
->snap_down_on
[a
]) {
132 p
= ts
->snap_down
[a
];
133 ts
->snap_state
[f
][a
] = 1;
134 } else if (p
>= ts
->snap_up_on
[a
]) {
136 ts
->snap_state
[f
][a
] = 1;
145 if (ts
->flags
& SYNAPTICS_SWAP_XY
)
146 swap(pos
[f
][0], pos
[f
][1]);
149 input_report_abs(ts
->input_dev
, ABS_X
, pos
[0][0]);
150 input_report_abs(ts
->input_dev
, ABS_Y
, pos
[0][1]);
152 input_report_abs(ts
->input_dev
, ABS_PRESSURE
, z
);
153 input_report_abs(ts
->input_dev
, ABS_TOOL_WIDTH
, w
);
154 input_report_key(ts
->input_dev
, BTN_TOUCH
, finger
);
155 finger2_pressed
= finger
> 1 && finger
!= 7;
156 input_report_key(ts
->input_dev
, BTN_2
, finger2_pressed
);
157 if (finger2_pressed
) {
158 input_report_abs(ts
->input_dev
, ABS_HAT0X
, pos
[1][0]);
159 input_report_abs(ts
->input_dev
, ABS_HAT0Y
, pos
[1][1]);
161 input_sync(ts
->input_dev
);
164 static void synaptics_ts_work_func(struct work_struct
*work
)
169 struct i2c_msg msg
[2];
172 struct synaptics_ts_data
*ts
=
173 container_of(work
, struct synaptics_ts_data
, work
);
175 msg
[0].addr
= ts
->client
->addr
;
178 msg
[0].buf
= &start_reg
;
179 msg
[1].addr
= ts
->client
->addr
;
180 msg
[1].flags
= I2C_M_RD
;
181 msg
[1].len
= sizeof(buf
);
184 for (i
= 0; i
< ((ts
->use_irq
&& !bad_data
) ? 1 : 10); i
++) {
185 ret
= i2c_transfer(ts
->client
->adapter
, msg
, 2);
187 pr_err("ts_work: i2c_transfer failed\n");
191 if ((buf
[14] & 0xc0) != 0x40) {
192 pr_warning("synaptics_ts_work_func:"
193 " bad read %x %x %x %x %x %x %x %x %x"
194 " %x %x %x %x %x %x, ret %d\n",
195 buf
[0], buf
[1], buf
[2], buf
[3],
196 buf
[4], buf
[5], buf
[6], buf
[7],
197 buf
[8], buf
[9], buf
[10], buf
[11],
198 buf
[12], buf
[13], buf
[14], ret
);
200 synaptics_init_panel(ts
);
205 if ((buf
[14] & 1) == 0)
208 decode_report(ts
, buf
);
211 enable_irq(ts
->client
->irq
);
214 static enum hrtimer_restart
synaptics_ts_timer_func(struct hrtimer
*timer
)
216 struct synaptics_ts_data
*ts
=
217 container_of(timer
, struct synaptics_ts_data
, timer
);
219 queue_work(synaptics_wq
, &ts
->work
);
221 hrtimer_start(&ts
->timer
, ktime_set(0, 12500000), HRTIMER_MODE_REL
);
222 return HRTIMER_NORESTART
;
225 static irqreturn_t
synaptics_ts_irq_handler(int irq
, void *dev_id
)
227 struct synaptics_ts_data
*ts
= dev_id
;
229 disable_irq_nosync(ts
->client
->irq
);
230 queue_work(synaptics_wq
, &ts
->work
);
234 static int detect(struct synaptics_ts_data
*ts
, u32
*panel_version
)
239 ret
= i2c_set(ts
, 0xf4, 0x01, "reset device");
241 while (retry
-- > 0) {
242 ret
= i2c_smbus_read_byte_data(ts
->client
, 0xe4);
248 pr_err("i2c_smbus_read_byte_data failed\n");
252 *panel_version
= ret
<< 8;
253 ret
= i2c_read(ts
, 0xe5, "product minor");
256 *panel_version
|= ret
;
258 ret
= i2c_read(ts
, 0xe3, "property");
262 pr_info("synaptics: version %x, product property %x\n",
263 *panel_version
, ret
);
267 static void compute_areas(struct synaptics_ts_data
*ts
,
268 struct synaptics_i2c_rmi_platform_data
*pdata
,
269 u16 max_x
, u16 max_y
)
271 int inactive_area_left
;
272 int inactive_area_right
;
273 int inactive_area_top
;
274 int inactive_area_bottom
;
287 int swapped
= !!(ts
->flags
& SYNAPTICS_SWAP_XY
);
289 inactive_area_left
= pdata
->inactive_left
;
290 inactive_area_right
= pdata
->inactive_right
;
291 inactive_area_top
= pdata
->inactive_top
;
292 inactive_area_bottom
= pdata
->inactive_bottom
;
293 snap_left_on
= pdata
->snap_left_on
;
294 snap_left_off
= pdata
->snap_left_off
;
295 snap_right_on
= pdata
->snap_right_on
;
296 snap_right_off
= pdata
->snap_right_off
;
297 snap_top_on
= pdata
->snap_top_on
;
298 snap_top_off
= pdata
->snap_top_off
;
299 snap_bottom_on
= pdata
->snap_bottom_on
;
300 snap_bottom_off
= pdata
->snap_bottom_off
;
301 fuzz_x
= pdata
->fuzz_x
;
302 fuzz_y
= pdata
->fuzz_y
;
303 fuzz_p
= pdata
->fuzz_p
;
304 fuzz_w
= pdata
->fuzz_w
;
306 inactive_area_left
= inactive_area_left
* max_x
/ 0x10000;
307 inactive_area_right
= inactive_area_right
* max_x
/ 0x10000;
308 inactive_area_top
= inactive_area_top
* max_y
/ 0x10000;
309 inactive_area_bottom
= inactive_area_bottom
* max_y
/ 0x10000;
310 snap_left_on
= snap_left_on
* max_x
/ 0x10000;
311 snap_left_off
= snap_left_off
* max_x
/ 0x10000;
312 snap_right_on
= snap_right_on
* max_x
/ 0x10000;
313 snap_right_off
= snap_right_off
* max_x
/ 0x10000;
314 snap_top_on
= snap_top_on
* max_y
/ 0x10000;
315 snap_top_off
= snap_top_off
* max_y
/ 0x10000;
316 snap_bottom_on
= snap_bottom_on
* max_y
/ 0x10000;
317 snap_bottom_off
= snap_bottom_off
* max_y
/ 0x10000;
318 fuzz_x
= fuzz_x
* max_x
/ 0x10000;
319 fuzz_y
= fuzz_y
* max_y
/ 0x10000;
322 ts
->snap_down
[swapped
] = -inactive_area_left
;
323 ts
->snap_up
[swapped
] = max_x
+ inactive_area_right
;
324 ts
->snap_down
[!swapped
] = -inactive_area_top
;
325 ts
->snap_up
[!swapped
] = max_y
+ inactive_area_bottom
;
326 ts
->snap_down_on
[swapped
] = snap_left_on
;
327 ts
->snap_down_off
[swapped
] = snap_left_off
;
328 ts
->snap_up_on
[swapped
] = max_x
- snap_right_on
;
329 ts
->snap_up_off
[swapped
] = max_x
- snap_right_off
;
330 ts
->snap_down_on
[!swapped
] = snap_top_on
;
331 ts
->snap_down_off
[!swapped
] = snap_top_off
;
332 ts
->snap_up_on
[!swapped
] = max_y
- snap_bottom_on
;
333 ts
->snap_up_off
[!swapped
] = max_y
- snap_bottom_off
;
334 pr_info("synaptics_ts_probe: max_x %d, max_y %d\n", max_x
, max_y
);
335 pr_info("synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
336 inactive_area_left
, inactive_area_right
,
337 inactive_area_top
, inactive_area_bottom
);
338 pr_info("synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
339 snap_left_on
, snap_left_off
, snap_right_on
, snap_right_off
,
340 snap_top_on
, snap_top_off
, snap_bottom_on
, snap_bottom_off
);
342 input_set_abs_params(ts
->input_dev
, ABS_X
,
343 -inactive_area_left
, max_x
+ inactive_area_right
,
345 input_set_abs_params(ts
->input_dev
, ABS_Y
,
346 -inactive_area_top
, max_y
+ inactive_area_bottom
,
348 input_set_abs_params(ts
->input_dev
, ABS_PRESSURE
, 0, 255, fuzz_p
, 0);
349 input_set_abs_params(ts
->input_dev
, ABS_TOOL_WIDTH
, 0, 15, fuzz_w
, 0);
350 input_set_abs_params(ts
->input_dev
, ABS_HAT0X
, -inactive_area_left
,
351 max_x
+ inactive_area_right
, fuzz_x
, 0);
352 input_set_abs_params(ts
->input_dev
, ABS_HAT0Y
, -inactive_area_top
,
353 max_y
+ inactive_area_bottom
, fuzz_y
, 0);
356 static struct synaptics_i2c_rmi_platform_data fake_pdata
;
358 static int __devinit
synaptics_ts_probe(
359 struct i2c_client
*client
, const struct i2c_device_id
*id
)
361 struct synaptics_ts_data
*ts
;
364 struct i2c_msg msg
[2];
366 struct synaptics_i2c_rmi_platform_data
*pdata
;
367 u32 panel_version
= 0;
370 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
371 pr_err("synaptics_ts_probe: need I2C_FUNC_I2C\n");
373 goto err_check_functionality_failed
;
376 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
377 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
379 goto err_check_functionality_failed
;
382 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
383 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
385 goto err_check_functionality_failed
;
388 ts
= kzalloc(sizeof(*ts
), GFP_KERNEL
);
391 goto err_alloc_data_failed
;
393 INIT_WORK(&ts
->work
, synaptics_ts_work_func
);
395 i2c_set_clientdata(client
, ts
);
396 pdata
= client
->dev
.platform_data
;
398 ts
->power
= pdata
->power
;
405 pr_err("synaptics_ts_probe power on failed\n");
406 goto err_power_failed
;
410 ret
= detect(ts
, &panel_version
);
412 goto err_detect_failed
;
414 while (pdata
->version
> panel_version
)
416 ts
->flags
= pdata
->flags
;
418 ret
= i2c_read(ts
, 0xf0, "device control");
420 goto err_detect_failed
;
421 pr_info("synaptics: device control %x\n", ret
);
423 ret
= i2c_read(ts
, 0xf1, "interrupt enable");
425 goto err_detect_failed
;
426 pr_info("synaptics_ts_probe: interrupt enable %x\n", ret
);
428 ret
= i2c_set(ts
, 0xf1, 0, "disable interrupt");
430 goto err_detect_failed
;
432 msg
[0].addr
= ts
->client
->addr
;
437 msg
[1].addr
= ts
->client
->addr
;
438 msg
[1].flags
= I2C_M_RD
;
441 ret
= i2c_transfer(ts
->client
->adapter
, msg
, 2);
443 pr_err("i2c_transfer failed\n");
444 goto err_detect_failed
;
446 pr_info("synaptics_ts_probe: 0xe0: %x %x %x %x %x %x %x %x\n",
447 buf1
[0], buf1
[1], buf1
[2], buf1
[3],
448 buf1
[4], buf1
[5], buf1
[6], buf1
[7]);
450 ret
= i2c_set(ts
, 0xff, 0x10, "page select = 0x10");
452 goto err_detect_failed
;
454 ret
= i2c_smbus_read_word_data(ts
->client
, 0x04);
456 pr_err("i2c_smbus_read_word_data failed\n");
457 goto err_detect_failed
;
459 ts
->max
[0] = max_x
= (ret
>> 8 & 0xff) | ((ret
& 0x1f) << 8);
460 ret
= i2c_smbus_read_word_data(ts
->client
, 0x06);
462 pr_err("i2c_smbus_read_word_data failed\n");
463 goto err_detect_failed
;
465 ts
->max
[1] = max_y
= (ret
>> 8 & 0xff) | ((ret
& 0x1f) << 8);
466 if (ts
->flags
& SYNAPTICS_SWAP_XY
)
469 /* will also switch back to page 0x04 */
470 ret
= synaptics_init_panel(ts
);
472 pr_err("synaptics_init_panel failed\n");
473 goto err_detect_failed
;
476 ts
->input_dev
= input_allocate_device();
477 if (ts
->input_dev
== NULL
) {
479 pr_err("synaptics: Failed to allocate input device\n");
480 goto err_input_dev_alloc_failed
;
482 ts
->input_dev
->name
= "synaptics-rmi-touchscreen";
483 ts
->input_dev
->phys
= "msm/input0";
484 ts
->input_dev
->id
.bustype
= BUS_I2C
;
486 __set_bit(EV_SYN
, ts
->input_dev
->evbit
);
487 __set_bit(EV_KEY
, ts
->input_dev
->evbit
);
488 __set_bit(BTN_TOUCH
, ts
->input_dev
->keybit
);
489 __set_bit(BTN_2
, ts
->input_dev
->keybit
);
490 __set_bit(EV_ABS
, ts
->input_dev
->evbit
);
492 compute_areas(ts
, pdata
, max_x
, max_y
);
495 ret
= input_register_device(ts
->input_dev
);
497 pr_err("synaptics: Unable to register %s input device\n",
498 ts
->input_dev
->name
);
499 goto err_input_register_device_failed
;
502 ret
= request_irq(client
->irq
, synaptics_ts_irq_handler
,
503 0, client
->name
, ts
);
505 ret
= i2c_set(ts
, 0xf1, 0x01, "enable abs int");
507 free_irq(client
->irq
, ts
);
512 dev_err(&client
->dev
, "request_irq failed\n");
515 hrtimer_init(&ts
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
516 ts
->timer
.function
= synaptics_ts_timer_func
;
517 hrtimer_start(&ts
->timer
, ktime_set(1, 0), HRTIMER_MODE_REL
);
519 #ifdef CONFIG_HAS_EARLYSUSPEND
520 ts
->early_suspend
.level
= EARLY_SUSPEND_LEVEL_BLANK_SCREEN
+ 1;
521 ts
->early_suspend
.suspend
= synaptics_ts_early_suspend
;
522 ts
->early_suspend
.resume
= synaptics_ts_late_resume
;
523 register_early_suspend(&ts
->early_suspend
);
526 pr_info("synaptics: Start touchscreen %s in %s mode\n",
527 ts
->input_dev
->name
, ts
->use_irq
? "interrupt" : "polling");
531 err_input_register_device_failed
:
532 input_free_device(ts
->input_dev
);
534 err_input_dev_alloc_failed
:
538 err_alloc_data_failed
:
539 err_check_functionality_failed
:
543 static int synaptics_ts_remove(struct i2c_client
*client
)
545 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
546 #ifdef CONFIG_HAS_EARLYSUSPEND
547 unregister_early_suspend(&ts
->early_suspend
);
550 free_irq(client
->irq
, ts
);
552 hrtimer_cancel(&ts
->timer
);
553 input_unregister_device(ts
->input_dev
);
559 static int synaptics_ts_suspend(struct i2c_client
*client
, pm_message_t mesg
)
562 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
565 disable_irq(client
->irq
);
567 hrtimer_cancel(&ts
->timer
);
568 ret
= cancel_work_sync(&ts
->work
);
569 if (ret
&& ts
->use_irq
) /* if work was pending disable-count is now 2 */
570 enable_irq(client
->irq
);
571 i2c_set(ts
, 0xf1, 0, "disable interrupt");
572 i2c_set(ts
, 0xf0, 0x86, "deep sleep");
577 pr_err("synaptics_ts_suspend power off failed\n");
582 static int synaptics_ts_resume(struct i2c_client
*client
)
585 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
590 pr_err("synaptics_ts_resume power on failed\n");
593 synaptics_init_panel(ts
);
596 enable_irq(client
->irq
);
597 i2c_set(ts
, 0xf1, 0x01, "enable abs int");
599 hrtimer_start(&ts
->timer
, ktime_set(1, 0), HRTIMER_MODE_REL
);
604 #ifdef CONFIG_HAS_EARLYSUSPEND
605 static void synaptics_ts_early_suspend(struct early_suspend
*h
)
607 struct synaptics_ts_data
*ts
;
608 ts
= container_of(h
, struct synaptics_ts_data
, early_suspend
);
609 synaptics_ts_suspend(ts
->client
, PMSG_SUSPEND
);
612 static void synaptics_ts_late_resume(struct early_suspend
*h
)
614 struct synaptics_ts_data
*ts
;
615 ts
= container_of(h
, struct synaptics_ts_data
, early_suspend
);
616 synaptics_ts_resume(ts
->client
);
620 #define synaptics_ts_suspend NULL
621 #define synaptics_ts_resume NULL
626 static const struct i2c_device_id synaptics_ts_id
[] = {
627 { SYNAPTICS_I2C_RMI_NAME
, 0 },
631 static struct i2c_driver synaptics_ts_driver
= {
632 .probe
= synaptics_ts_probe
,
633 .remove
= synaptics_ts_remove
,
634 #ifndef CONFIG_HAS_EARLYSUSPEND
635 .suspend
= synaptics_ts_suspend
,
636 .resume
= synaptics_ts_resume
,
638 .id_table
= synaptics_ts_id
,
640 .name
= SYNAPTICS_I2C_RMI_NAME
,
644 static int __devinit
synaptics_ts_init(void)
646 synaptics_wq
= create_singlethread_workqueue("synaptics_wq");
649 return i2c_add_driver(&synaptics_ts_driver
);
652 static void __exit
synaptics_ts_exit(void)
654 i2c_del_driver(&synaptics_ts_driver
);
656 destroy_workqueue(synaptics_wq
);
659 module_init(synaptics_ts_init
);
660 module_exit(synaptics_ts_exit
);
662 MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
663 MODULE_LICENSE("GPL");
664 MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");