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.
112 int finger
= buf
[0] & 7;
114 for (f
= 0; f
< 2; f
++) {
115 u32 flip_flag
= SYNAPTICS_FLIP_X
;
116 for (a
= 0; a
< 2; a
++) {
117 int p
= buf
[base
+ 1];
118 p
|= (u16
)(buf
[base
] & 0x1f) << 8;
119 if (ts
->flags
& flip_flag
)
121 if (ts
->flags
& SYNAPTICS_SNAP_TO_INACTIVE_EDGE
) {
122 if (ts
->snap_state
[f
][a
]) {
123 if (p
<= ts
->snap_down_off
[a
])
124 p
= ts
->snap_down
[a
];
125 else if (p
>= ts
->snap_up_off
[a
])
128 ts
->snap_state
[f
][a
] = 0;
130 if (p
<= ts
->snap_down_on
[a
]) {
131 p
= ts
->snap_down
[a
];
132 ts
->snap_state
[f
][a
] = 1;
133 } else if (p
>= ts
->snap_up_on
[a
]) {
135 ts
->snap_state
[f
][a
] = 1;
144 if (ts
->flags
& SYNAPTICS_SWAP_XY
)
145 swap(pos
[f
][0], pos
[f
][1]);
148 input_report_abs(ts
->input_dev
, ABS_X
, pos
[0][0]);
149 input_report_abs(ts
->input_dev
, ABS_Y
, pos
[0][1]);
151 input_report_abs(ts
->input_dev
, ABS_PRESSURE
, z
);
152 input_report_key(ts
->input_dev
, BTN_TOUCH
, finger
);
153 input_sync(ts
->input_dev
);
156 static void synaptics_ts_work_func(struct work_struct
*work
)
161 struct i2c_msg msg
[2];
164 struct synaptics_ts_data
*ts
=
165 container_of(work
, struct synaptics_ts_data
, work
);
167 msg
[0].addr
= ts
->client
->addr
;
170 msg
[0].buf
= &start_reg
;
171 msg
[1].addr
= ts
->client
->addr
;
172 msg
[1].flags
= I2C_M_RD
;
173 msg
[1].len
= sizeof(buf
);
176 for (i
= 0; i
< ((ts
->use_irq
&& !bad_data
) ? 1 : 10); i
++) {
177 ret
= i2c_transfer(ts
->client
->adapter
, msg
, 2);
179 pr_err("ts_work: i2c_transfer failed\n");
183 if ((buf
[14] & 0xc0) != 0x40) {
184 pr_warning("synaptics_ts_work_func:"
185 " bad read %x %x %x %x %x %x %x %x %x"
186 " %x %x %x %x %x %x, ret %d\n",
187 buf
[0], buf
[1], buf
[2], buf
[3],
188 buf
[4], buf
[5], buf
[6], buf
[7],
189 buf
[8], buf
[9], buf
[10], buf
[11],
190 buf
[12], buf
[13], buf
[14], ret
);
192 synaptics_init_panel(ts
);
197 if ((buf
[14] & 1) == 0)
200 decode_report(ts
, buf
);
204 static enum hrtimer_restart
synaptics_ts_timer_func(struct hrtimer
*timer
)
206 struct synaptics_ts_data
*ts
=
207 container_of(timer
, struct synaptics_ts_data
, timer
);
209 queue_work(synaptics_wq
, &ts
->work
);
211 hrtimer_start(&ts
->timer
, ktime_set(0, 12500000), HRTIMER_MODE_REL
);
212 return HRTIMER_NORESTART
;
215 static irqreturn_t
synaptics_ts_irq_handler(int irq
, void *dev_id
)
217 struct synaptics_ts_data
*ts
= dev_id
;
219 synaptics_ts_work_func(&ts
->work
);
223 static int detect(struct synaptics_ts_data
*ts
, u32
*panel_version
)
228 ret
= i2c_set(ts
, 0xf4, 0x01, "reset device");
230 while (retry
-- > 0) {
231 ret
= i2c_smbus_read_byte_data(ts
->client
, 0xe4);
237 pr_err("i2c_smbus_read_byte_data failed\n");
241 *panel_version
= ret
<< 8;
242 ret
= i2c_read(ts
, 0xe5, "product minor");
245 *panel_version
|= ret
;
247 ret
= i2c_read(ts
, 0xe3, "property");
251 pr_info("synaptics: version %x, product property %x\n",
252 *panel_version
, ret
);
256 static void compute_areas(struct synaptics_ts_data
*ts
,
257 struct synaptics_i2c_rmi_platform_data
*pdata
,
258 u16 max_x
, u16 max_y
)
260 int inactive_area_left
;
261 int inactive_area_right
;
262 int inactive_area_top
;
263 int inactive_area_bottom
;
276 int swapped
= !!(ts
->flags
& SYNAPTICS_SWAP_XY
);
278 inactive_area_left
= pdata
->inactive_left
;
279 inactive_area_right
= pdata
->inactive_right
;
280 inactive_area_top
= pdata
->inactive_top
;
281 inactive_area_bottom
= pdata
->inactive_bottom
;
282 snap_left_on
= pdata
->snap_left_on
;
283 snap_left_off
= pdata
->snap_left_off
;
284 snap_right_on
= pdata
->snap_right_on
;
285 snap_right_off
= pdata
->snap_right_off
;
286 snap_top_on
= pdata
->snap_top_on
;
287 snap_top_off
= pdata
->snap_top_off
;
288 snap_bottom_on
= pdata
->snap_bottom_on
;
289 snap_bottom_off
= pdata
->snap_bottom_off
;
290 fuzz_x
= pdata
->fuzz_x
;
291 fuzz_y
= pdata
->fuzz_y
;
292 fuzz_p
= pdata
->fuzz_p
;
293 fuzz_w
= pdata
->fuzz_w
;
295 inactive_area_left
= inactive_area_left
* max_x
/ 0x10000;
296 inactive_area_right
= inactive_area_right
* max_x
/ 0x10000;
297 inactive_area_top
= inactive_area_top
* max_y
/ 0x10000;
298 inactive_area_bottom
= inactive_area_bottom
* max_y
/ 0x10000;
299 snap_left_on
= snap_left_on
* max_x
/ 0x10000;
300 snap_left_off
= snap_left_off
* max_x
/ 0x10000;
301 snap_right_on
= snap_right_on
* max_x
/ 0x10000;
302 snap_right_off
= snap_right_off
* max_x
/ 0x10000;
303 snap_top_on
= snap_top_on
* max_y
/ 0x10000;
304 snap_top_off
= snap_top_off
* max_y
/ 0x10000;
305 snap_bottom_on
= snap_bottom_on
* max_y
/ 0x10000;
306 snap_bottom_off
= snap_bottom_off
* max_y
/ 0x10000;
307 fuzz_x
= fuzz_x
* max_x
/ 0x10000;
308 fuzz_y
= fuzz_y
* max_y
/ 0x10000;
311 ts
->snap_down
[swapped
] = -inactive_area_left
;
312 ts
->snap_up
[swapped
] = max_x
+ inactive_area_right
;
313 ts
->snap_down
[!swapped
] = -inactive_area_top
;
314 ts
->snap_up
[!swapped
] = max_y
+ inactive_area_bottom
;
315 ts
->snap_down_on
[swapped
] = snap_left_on
;
316 ts
->snap_down_off
[swapped
] = snap_left_off
;
317 ts
->snap_up_on
[swapped
] = max_x
- snap_right_on
;
318 ts
->snap_up_off
[swapped
] = max_x
- snap_right_off
;
319 ts
->snap_down_on
[!swapped
] = snap_top_on
;
320 ts
->snap_down_off
[!swapped
] = snap_top_off
;
321 ts
->snap_up_on
[!swapped
] = max_y
- snap_bottom_on
;
322 ts
->snap_up_off
[!swapped
] = max_y
- snap_bottom_off
;
323 pr_info("synaptics_ts_probe: max_x %d, max_y %d\n", max_x
, max_y
);
324 pr_info("synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
325 inactive_area_left
, inactive_area_right
,
326 inactive_area_top
, inactive_area_bottom
);
327 pr_info("synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
328 snap_left_on
, snap_left_off
, snap_right_on
, snap_right_off
,
329 snap_top_on
, snap_top_off
, snap_bottom_on
, snap_bottom_off
);
331 input_set_abs_params(ts
->input_dev
, ABS_X
,
332 -inactive_area_left
, max_x
+ inactive_area_right
,
334 input_set_abs_params(ts
->input_dev
, ABS_Y
,
335 -inactive_area_top
, max_y
+ inactive_area_bottom
,
337 input_set_abs_params(ts
->input_dev
, ABS_PRESSURE
, 0, 255, fuzz_p
, 0);
340 static struct synaptics_i2c_rmi_platform_data fake_pdata
;
342 static int __devinit
synaptics_ts_probe(
343 struct i2c_client
*client
, const struct i2c_device_id
*id
)
345 struct synaptics_ts_data
*ts
;
348 struct i2c_msg msg
[2];
350 struct synaptics_i2c_rmi_platform_data
*pdata
;
351 u32 panel_version
= 0;
354 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
355 pr_err("synaptics_ts_probe: need I2C_FUNC_I2C\n");
357 goto err_check_functionality_failed
;
360 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
361 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
363 goto err_check_functionality_failed
;
366 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
367 pr_err("synaptics_ts_probe: need I2C_FUNC_SMBUS_WORD_DATA\n");
369 goto err_check_functionality_failed
;
372 ts
= kzalloc(sizeof(*ts
), GFP_KERNEL
);
375 goto err_alloc_data_failed
;
377 INIT_WORK(&ts
->work
, synaptics_ts_work_func
);
379 i2c_set_clientdata(client
, ts
);
380 pdata
= client
->dev
.platform_data
;
382 ts
->power
= pdata
->power
;
389 pr_err("synaptics_ts_probe power on failed\n");
390 goto err_power_failed
;
394 ret
= detect(ts
, &panel_version
);
396 goto err_detect_failed
;
398 while (pdata
->version
> panel_version
)
400 ts
->flags
= pdata
->flags
;
402 ret
= i2c_read(ts
, 0xf0, "device control");
404 goto err_detect_failed
;
405 pr_info("synaptics: device control %x\n", ret
);
407 ret
= i2c_read(ts
, 0xf1, "interrupt enable");
409 goto err_detect_failed
;
410 pr_info("synaptics_ts_probe: interrupt enable %x\n", ret
);
412 ret
= i2c_set(ts
, 0xf1, 0, "disable interrupt");
414 goto err_detect_failed
;
416 msg
[0].addr
= ts
->client
->addr
;
421 msg
[1].addr
= ts
->client
->addr
;
422 msg
[1].flags
= I2C_M_RD
;
425 ret
= i2c_transfer(ts
->client
->adapter
, msg
, 2);
427 pr_err("i2c_transfer failed\n");
428 goto err_detect_failed
;
430 pr_info("synaptics_ts_probe: 0xe0: %x %x %x %x %x %x %x %x\n",
431 buf1
[0], buf1
[1], buf1
[2], buf1
[3],
432 buf1
[4], buf1
[5], buf1
[6], buf1
[7]);
434 ret
= i2c_set(ts
, 0xff, 0x10, "page select = 0x10");
436 goto err_detect_failed
;
438 ret
= i2c_smbus_read_word_data(ts
->client
, 0x04);
440 pr_err("i2c_smbus_read_word_data failed\n");
441 goto err_detect_failed
;
443 ts
->max
[0] = max_x
= (ret
>> 8 & 0xff) | ((ret
& 0x1f) << 8);
444 ret
= i2c_smbus_read_word_data(ts
->client
, 0x06);
446 pr_err("i2c_smbus_read_word_data failed\n");
447 goto err_detect_failed
;
449 ts
->max
[1] = max_y
= (ret
>> 8 & 0xff) | ((ret
& 0x1f) << 8);
450 if (ts
->flags
& SYNAPTICS_SWAP_XY
)
453 /* will also switch back to page 0x04 */
454 ret
= synaptics_init_panel(ts
);
456 pr_err("synaptics_init_panel failed\n");
457 goto err_detect_failed
;
460 ts
->input_dev
= input_allocate_device();
461 if (ts
->input_dev
== NULL
) {
463 pr_err("synaptics: Failed to allocate input device\n");
464 goto err_input_dev_alloc_failed
;
466 ts
->input_dev
->name
= "synaptics-rmi-touchscreen";
467 ts
->input_dev
->phys
= "msm/input0";
468 ts
->input_dev
->id
.bustype
= BUS_I2C
;
470 __set_bit(EV_SYN
, ts
->input_dev
->evbit
);
471 __set_bit(EV_KEY
, ts
->input_dev
->evbit
);
472 __set_bit(BTN_TOUCH
, ts
->input_dev
->keybit
);
473 __set_bit(EV_ABS
, ts
->input_dev
->evbit
);
475 compute_areas(ts
, pdata
, max_x
, max_y
);
478 ret
= input_register_device(ts
->input_dev
);
480 pr_err("synaptics: Unable to register %s input device\n",
481 ts
->input_dev
->name
);
482 goto err_input_register_device_failed
;
485 ret
= request_threaded_irq(client
->irq
, NULL
,
486 synaptics_ts_irq_handler
,
487 IRQF_TRIGGER_LOW
|IRQF_ONESHOT
,
490 ret
= i2c_set(ts
, 0xf1, 0x01, "enable abs int");
492 free_irq(client
->irq
, ts
);
497 dev_err(&client
->dev
, "request_irq failed\n");
500 hrtimer_init(&ts
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
501 ts
->timer
.function
= synaptics_ts_timer_func
;
502 hrtimer_start(&ts
->timer
, ktime_set(1, 0), HRTIMER_MODE_REL
);
504 #ifdef CONFIG_HAS_EARLYSUSPEND
505 ts
->early_suspend
.level
= EARLY_SUSPEND_LEVEL_BLANK_SCREEN
+ 1;
506 ts
->early_suspend
.suspend
= synaptics_ts_early_suspend
;
507 ts
->early_suspend
.resume
= synaptics_ts_late_resume
;
508 register_early_suspend(&ts
->early_suspend
);
511 pr_info("synaptics: Start touchscreen %s in %s mode\n",
512 ts
->input_dev
->name
, ts
->use_irq
? "interrupt" : "polling");
516 err_input_register_device_failed
:
517 input_free_device(ts
->input_dev
);
519 err_input_dev_alloc_failed
:
523 err_alloc_data_failed
:
524 err_check_functionality_failed
:
528 static int synaptics_ts_remove(struct i2c_client
*client
)
530 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
531 #ifdef CONFIG_HAS_EARLYSUSPEND
532 unregister_early_suspend(&ts
->early_suspend
);
535 free_irq(client
->irq
, ts
);
537 hrtimer_cancel(&ts
->timer
);
538 input_unregister_device(ts
->input_dev
);
544 static int synaptics_ts_suspend(struct i2c_client
*client
, pm_message_t mesg
)
547 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
550 disable_irq(client
->irq
);
552 hrtimer_cancel(&ts
->timer
);
553 ret
= cancel_work_sync(&ts
->work
);
554 if (ret
&& ts
->use_irq
) /* if work was pending disable-count is now 2 */
555 enable_irq(client
->irq
);
556 i2c_set(ts
, 0xf1, 0, "disable interrupt");
557 i2c_set(ts
, 0xf0, 0x86, "deep sleep");
562 pr_err("synaptics_ts_suspend power off failed\n");
567 static int synaptics_ts_resume(struct i2c_client
*client
)
570 struct synaptics_ts_data
*ts
= i2c_get_clientdata(client
);
575 pr_err("synaptics_ts_resume power on failed\n");
578 synaptics_init_panel(ts
);
581 enable_irq(client
->irq
);
582 i2c_set(ts
, 0xf1, 0x01, "enable abs int");
584 hrtimer_start(&ts
->timer
, ktime_set(1, 0), HRTIMER_MODE_REL
);
589 #ifdef CONFIG_HAS_EARLYSUSPEND
590 static void synaptics_ts_early_suspend(struct early_suspend
*h
)
592 struct synaptics_ts_data
*ts
;
593 ts
= container_of(h
, struct synaptics_ts_data
, early_suspend
);
594 synaptics_ts_suspend(ts
->client
, PMSG_SUSPEND
);
597 static void synaptics_ts_late_resume(struct early_suspend
*h
)
599 struct synaptics_ts_data
*ts
;
600 ts
= container_of(h
, struct synaptics_ts_data
, early_suspend
);
601 synaptics_ts_resume(ts
->client
);
605 #define synaptics_ts_suspend NULL
606 #define synaptics_ts_resume NULL
611 static const struct i2c_device_id synaptics_ts_id
[] = {
612 { SYNAPTICS_I2C_RMI_NAME
, 0 },
616 static struct i2c_driver synaptics_ts_driver
= {
617 .probe
= synaptics_ts_probe
,
618 .remove
= synaptics_ts_remove
,
619 #ifndef CONFIG_HAS_EARLYSUSPEND
620 .suspend
= synaptics_ts_suspend
,
621 .resume
= synaptics_ts_resume
,
623 .id_table
= synaptics_ts_id
,
625 .name
= SYNAPTICS_I2C_RMI_NAME
,
629 static int __devinit
synaptics_ts_init(void)
631 synaptics_wq
= create_singlethread_workqueue("synaptics_wq");
634 return i2c_add_driver(&synaptics_ts_driver
);
637 static void __exit
synaptics_ts_exit(void)
639 i2c_del_driver(&synaptics_ts_driver
);
641 destroy_workqueue(synaptics_wq
);
644 module_init(synaptics_ts_init
);
645 module_exit(synaptics_ts_exit
);
647 MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
648 MODULE_LICENSE("GPL");
649 MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");