1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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>
24#endif
25#include <linux/hrtimer.h>
26#include <linux/i2c.h>
27#include <linux/input.h>
28#include <linux/interrupt.h>
29#include <linux/io.h>
30#include <linux/platform_device.h>
31#include "synaptics_i2c_rmi.h"
32
33static struct workqueue_struct *synaptics_wq;
34
35struct synaptics_ts_data {
36 u16 addr;
37 struct i2c_client *client;
38 struct input_dev *input_dev;
39 int use_irq;
40 struct hrtimer timer;
41 struct work_struct work;
42 u16 max[2];
43 int snap_state[2][2];
44 int snap_down_on[2];
45 int snap_down_off[2];
46 int snap_up_on[2];
47 int snap_up_off[2];
48 int snap_down[2];
49 int snap_up[2];
50 u32 flags;
51 int (*power)(int on);
52#ifdef CONFIG_HAS_EARLYSUSPEND
53 struct early_suspend early_suspend;
54#endif
55};
56
57static int i2c_set(struct synaptics_ts_data *ts, u8 reg, u8 val, char *msg)
58{
59 int ret = i2c_smbus_write_byte_data(ts->client, reg, val);
60 if (ret < 0)
61 pr_err("i2c_smbus_write_byte_data failed (%s)\n", msg);
62 return ret;
63}
64
65static int i2c_read(struct synaptics_ts_data *ts, u8 reg, char *msg)
66{
67 int ret = i2c_smbus_read_byte_data(ts->client, reg);
68 if (ret < 0)
69 pr_err("i2c_smbus_read_byte_data failed (%s)\n", msg);
70 return ret;
71}
72#ifdef CONFIG_HAS_EARLYSUSPEND
73static void synaptics_ts_early_suspend(struct early_suspend *h);
74static void synaptics_ts_late_resume(struct early_suspend *h);
75#endif
76
77static int synaptics_init_panel(struct synaptics_ts_data *ts)
78{
79 int ret;
80
81 ret = i2c_set(ts, 0xff, 0x10, "set page select");
82 if (ret == 0)
83 ret = i2c_set(ts, 0x41, 0x04, "set No Clip Z");
84
85 ret = i2c_set(ts, 0xff, 0x04, "fallback page select");
86 ret = i2c_set(ts, 0xf0, 0x81, "select 80 reports per second");
87 return ret;
88}
89
90static void decode_report(struct synaptics_ts_data *ts, u8 *buf)
91{
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108 int pos[2][2];
109 int f, a;
110 int base = 2;
111 int z = buf[1];
112 int finger = buf[0] & 7;
113
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)
120 p = ts->max[a] - p;
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])
126 p = ts->snap_up[a];
127 else
128 ts->snap_state[f][a] = 0;
129 } else {
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]) {
134 p = ts->snap_up[a];
135 ts->snap_state[f][a] = 1;
136 }
137 }
138 }
139 pos[f][a] = p;
140 base += 2;
141 flip_flag <<= 1;
142 }
143 base += 2;
144 if (ts->flags & SYNAPTICS_SWAP_XY)
145 swap(pos[f][0], pos[f][1]);
146 }
147 if (z) {
148 input_report_abs(ts->input_dev, ABS_X, pos[0][0]);
149 input_report_abs(ts->input_dev, ABS_Y, pos[0][1]);
150 }
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);
154}
155
156static void synaptics_ts_work_func(struct work_struct *work)
157{
158 int i;
159 int ret;
160 int bad_data = 0;
161 struct i2c_msg msg[2];
162 u8 start_reg = 0;
163 u8 buf[15];
164 struct synaptics_ts_data *ts =
165 container_of(work, struct synaptics_ts_data, work);
166
167 msg[0].addr = ts->client->addr;
168 msg[0].flags = 0;
169 msg[0].len = 1;
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);
174 msg[1].buf = buf;
175
176 for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
177 ret = i2c_transfer(ts->client->adapter, msg, 2);
178 if (ret < 0) {
179 pr_err("ts_work: i2c_transfer failed\n");
180 bad_data = 1;
181 continue;
182 }
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);
191 if (bad_data)
192 synaptics_init_panel(ts);
193 bad_data = 1;
194 continue;
195 }
196 bad_data = 0;
197 if ((buf[14] & 1) == 0)
198 break;
199
200 decode_report(ts, buf);
201 }
202}
203
204static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
205{
206 struct synaptics_ts_data *ts =
207 container_of(timer, struct synaptics_ts_data, timer);
208
209 queue_work(synaptics_wq, &ts->work);
210
211 hrtimer_start(&ts->timer, ktime_set(0, 12500000), HRTIMER_MODE_REL);
212 return HRTIMER_NORESTART;
213}
214
215static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
216{
217 struct synaptics_ts_data *ts = dev_id;
218
219 synaptics_ts_work_func(&ts->work);
220 return IRQ_HANDLED;
221}
222
223static int detect(struct synaptics_ts_data *ts, u32 *panel_version)
224{
225 int ret;
226 int retry = 10;
227
228 ret = i2c_set(ts, 0xf4, 0x01, "reset device");
229
230 while (retry-- > 0) {
231 ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
232 if (ret >= 0)
233 break;
234 msleep(100);
235 }
236 if (ret < 0) {
237 pr_err("i2c_smbus_read_byte_data failed\n");
238 return ret;
239 }
240
241 *panel_version = ret << 8;
242 ret = i2c_read(ts, 0xe5, "product minor");
243 if (ret < 0)
244 return ret;
245 *panel_version |= ret;
246
247 ret = i2c_read(ts, 0xe3, "property");
248 if (ret < 0)
249 return ret;
250
251 pr_info("synaptics: version %x, product property %x\n",
252 *panel_version, ret);
253 return 0;
254}
255
256static void compute_areas(struct synaptics_ts_data *ts,
257 struct synaptics_i2c_rmi_platform_data *pdata,
258 u16 max_x, u16 max_y)
259{
260 int inactive_area_left;
261 int inactive_area_right;
262 int inactive_area_top;
263 int inactive_area_bottom;
264 int snap_left_on;
265 int snap_left_off;
266 int snap_right_on;
267 int snap_right_off;
268 int snap_top_on;
269 int snap_top_off;
270 int snap_bottom_on;
271 int snap_bottom_off;
272 int fuzz_x;
273 int fuzz_y;
274 int fuzz_p;
275 int fuzz_w;
276 int swapped = !!(ts->flags & SYNAPTICS_SWAP_XY);
277
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;
294
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;
309
310
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);
330
331 input_set_abs_params(ts->input_dev, ABS_X,
332 -inactive_area_left, max_x + inactive_area_right,
333 fuzz_x, 0);
334 input_set_abs_params(ts->input_dev, ABS_Y,
335 -inactive_area_top, max_y + inactive_area_bottom,
336 fuzz_y, 0);
337 input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0);
338}
339
340static struct synaptics_i2c_rmi_platform_data fake_pdata;
341
342static int __devinit synaptics_ts_probe(
343 struct i2c_client *client, const struct i2c_device_id *id)
344{
345 struct synaptics_ts_data *ts;
346 u8 buf0[4];
347 u8 buf1[8];
348 struct i2c_msg msg[2];
349 int ret = 0;
350 struct synaptics_i2c_rmi_platform_data *pdata;
351 u32 panel_version = 0;
352 u16 max_x, max_y;
353
354 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
355 pr_err("synaptics_ts_probe: need I2C_FUNC_I2C\n");
356 ret = -ENODEV;
357 goto err_check_functionality_failed;
358 }
359
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");
362 ret = -ENODEV;
363 goto err_check_functionality_failed;
364 }
365
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");
368 ret = -ENODEV;
369 goto err_check_functionality_failed;
370 }
371
372 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
373 if (ts == NULL) {
374 ret = -ENOMEM;
375 goto err_alloc_data_failed;
376 }
377 INIT_WORK(&ts->work, synaptics_ts_work_func);
378 ts->client = client;
379 i2c_set_clientdata(client, ts);
380 pdata = client->dev.platform_data;
381 if (pdata)
382 ts->power = pdata->power;
383 else
384 pdata = &fake_pdata;
385
386 if (ts->power) {
387 ret = ts->power(1);
388 if (ret < 0) {
389 pr_err("synaptics_ts_probe power on failed\n");
390 goto err_power_failed;
391 }
392 }
393
394 ret = detect(ts, &panel_version);
395 if (ret)
396 goto err_detect_failed;
397
398 while (pdata->version > panel_version)
399 pdata++;
400 ts->flags = pdata->flags;
401
402 ret = i2c_read(ts, 0xf0, "device control");
403 if (ret < 0)
404 goto err_detect_failed;
405 pr_info("synaptics: device control %x\n", ret);
406
407 ret = i2c_read(ts, 0xf1, "interrupt enable");
408 if (ret < 0)
409 goto err_detect_failed;
410 pr_info("synaptics_ts_probe: interrupt enable %x\n", ret);
411
412 ret = i2c_set(ts, 0xf1, 0, "disable interrupt");
413 if (ret < 0)
414 goto err_detect_failed;
415
416 msg[0].addr = ts->client->addr;
417 msg[0].flags = 0;
418 msg[0].len = 1;
419 msg[0].buf = buf0;
420 buf0[0] = 0xe0;
421 msg[1].addr = ts->client->addr;
422 msg[1].flags = I2C_M_RD;
423 msg[1].len = 8;
424 msg[1].buf = buf1;
425 ret = i2c_transfer(ts->client->adapter, msg, 2);
426 if (ret < 0) {
427 pr_err("i2c_transfer failed\n");
428 goto err_detect_failed;
429 }
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]);
433
434 ret = i2c_set(ts, 0xff, 0x10, "page select = 0x10");
435 if (ret < 0)
436 goto err_detect_failed;
437
438 ret = i2c_smbus_read_word_data(ts->client, 0x04);
439 if (ret < 0) {
440 pr_err("i2c_smbus_read_word_data failed\n");
441 goto err_detect_failed;
442 }
443 ts->max[0] = max_x = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
444 ret = i2c_smbus_read_word_data(ts->client, 0x06);
445 if (ret < 0) {
446 pr_err("i2c_smbus_read_word_data failed\n");
447 goto err_detect_failed;
448 }
449 ts->max[1] = max_y = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8);
450 if (ts->flags & SYNAPTICS_SWAP_XY)
451 swap(max_x, max_y);
452
453
454 ret = synaptics_init_panel(ts);
455 if (ret < 0) {
456 pr_err("synaptics_init_panel failed\n");
457 goto err_detect_failed;
458 }
459
460 ts->input_dev = input_allocate_device();
461 if (ts->input_dev == NULL) {
462 ret = -ENOMEM;
463 pr_err("synaptics: Failed to allocate input device\n");
464 goto err_input_dev_alloc_failed;
465 }
466 ts->input_dev->name = "synaptics-rmi-touchscreen";
467 ts->input_dev->phys = "msm/input0";
468 ts->input_dev->id.bustype = BUS_I2C;
469
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);
474
475 compute_areas(ts, pdata, max_x, max_y);
476
477
478 ret = input_register_device(ts->input_dev);
479 if (ret) {
480 pr_err("synaptics: Unable to register %s input device\n",
481 ts->input_dev->name);
482 goto err_input_register_device_failed;
483 }
484 if (client->irq) {
485 ret = request_threaded_irq(client->irq, NULL,
486 synaptics_ts_irq_handler,
487 IRQF_TRIGGER_LOW|IRQF_ONESHOT,
488 client->name, ts);
489 if (ret == 0) {
490 ret = i2c_set(ts, 0xf1, 0x01, "enable abs int");
491 if (ret)
492 free_irq(client->irq, ts);
493 }
494 if (ret == 0)
495 ts->use_irq = 1;
496 else
497 dev_err(&client->dev, "request_irq failed\n");
498 }
499 if (!ts->use_irq) {
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);
503 }
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);
509#endif
510
511 pr_info("synaptics: Start touchscreen %s in %s mode\n",
512 ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
513
514 return 0;
515
516err_input_register_device_failed:
517 input_free_device(ts->input_dev);
518
519err_input_dev_alloc_failed:
520err_detect_failed:
521err_power_failed:
522 kfree(ts);
523err_alloc_data_failed:
524err_check_functionality_failed:
525 return ret;
526}
527
528static int synaptics_ts_remove(struct i2c_client *client)
529{
530 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
531#ifdef CONFIG_HAS_EARLYSUSPEND
532 unregister_early_suspend(&ts->early_suspend);
533#endif
534 if (ts->use_irq)
535 free_irq(client->irq, ts);
536 else
537 hrtimer_cancel(&ts->timer);
538 input_unregister_device(ts->input_dev);
539 kfree(ts);
540 return 0;
541}
542
543#ifdef CONFIG_PM
544static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
545{
546 int ret;
547 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
548
549 if (ts->use_irq)
550 disable_irq(client->irq);
551 else
552 hrtimer_cancel(&ts->timer);
553 ret = cancel_work_sync(&ts->work);
554 if (ret && ts->use_irq)
555 enable_irq(client->irq);
556 i2c_set(ts, 0xf1, 0, "disable interrupt");
557 i2c_set(ts, 0xf0, 0x86, "deep sleep");
558
559 if (ts->power) {
560 ret = ts->power(0);
561 if (ret < 0)
562 pr_err("synaptics_ts_suspend power off failed\n");
563 }
564 return 0;
565}
566
567static int synaptics_ts_resume(struct i2c_client *client)
568{
569 int ret;
570 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
571
572 if (ts->power) {
573 ret = ts->power(1);
574 if (ret < 0)
575 pr_err("synaptics_ts_resume power on failed\n");
576 }
577
578 synaptics_init_panel(ts);
579
580 if (ts->use_irq) {
581 enable_irq(client->irq);
582 i2c_set(ts, 0xf1, 0x01, "enable abs int");
583 } else
584 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
585
586 return 0;
587}
588
589#ifdef CONFIG_HAS_EARLYSUSPEND
590static void synaptics_ts_early_suspend(struct early_suspend *h)
591{
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);
595}
596
597static void synaptics_ts_late_resume(struct early_suspend *h)
598{
599 struct synaptics_ts_data *ts;
600 ts = container_of(h, struct synaptics_ts_data, early_suspend);
601 synaptics_ts_resume(ts->client);
602}
603#endif
604#else
605#define synaptics_ts_suspend NULL
606#define synaptics_ts_resume NULL
607#endif
608
609
610
611static const struct i2c_device_id synaptics_ts_id[] = {
612 { SYNAPTICS_I2C_RMI_NAME, 0 },
613 { }
614};
615
616static 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,
622#endif
623 .id_table = synaptics_ts_id,
624 .driver = {
625 .name = SYNAPTICS_I2C_RMI_NAME,
626 },
627};
628
629static int __devinit synaptics_ts_init(void)
630{
631 synaptics_wq = create_singlethread_workqueue("synaptics_wq");
632 if (!synaptics_wq)
633 return -ENOMEM;
634 return i2c_add_driver(&synaptics_ts_driver);
635}
636
637static void __exit synaptics_ts_exit(void)
638{
639 i2c_del_driver(&synaptics_ts_driver);
640 if (synaptics_wq)
641 destroy_workqueue(synaptics_wq);
642}
643
644module_init(synaptics_ts_init);
645module_exit(synaptics_ts_exit);
646
647MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
648MODULE_LICENSE("GPL");
649MODULE_AUTHOR("Arve Hjønnevåg <arve@android.com>");
650
