1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/input.h>
29#include <linux/slab.h>
30#include <linux/i2c.h>
31#include <linux/interrupt.h>
32#include <linux/regulator/consumer.h>
33#include <linux/module.h>
34#include <linux/input/mt.h>
35#include "synaptics_i2c_rmi4.h"
36
37
38#define DRIVER_NAME "synaptics_rmi4_i2c"
39
40#define MAX_ERROR_REPORT 6
41#define MAX_TOUCH_MAJOR 15
42#define MAX_RETRY_COUNT 5
43#define STD_QUERY_LEN 21
44#define PAGE_LEN 2
45#define DATA_BUF_LEN 32
46#define BUF_LEN 37
47#define QUERY_LEN 9
48#define DATA_LEN 12
49#define HAS_TAP 0x01
50#define HAS_PALMDETECT 0x01
51#define HAS_ROTATE 0x02
52#define HAS_TAPANDHOLD 0x02
53#define HAS_DOUBLETAP 0x04
54#define HAS_EARLYTAP 0x08
55#define HAS_RELEASE 0x08
56#define HAS_FLICK 0x10
57#define HAS_PRESS 0x20
58#define HAS_PINCH 0x40
59
60#define MASK_16BIT 0xFFFF
61#define MASK_8BIT 0xFF
62#define MASK_7BIT 0x7F
63#define MASK_5BIT 0x1F
64#define MASK_4BIT 0x0F
65#define MASK_3BIT 0x07
66#define MASK_2BIT 0x03
67#define TOUCHPAD_CTRL_INTR 0x8
68#define PDT_START_SCAN_LOCATION (0x00E9)
69#define PDT_END_SCAN_LOCATION (0x000A)
70#define PDT_ENTRY_SIZE (0x0006)
71#define SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM (0x11)
72#define SYNAPTICS_RMI4_DEVICE_CONTROL_FUNC_NUM (0x01)
73
74
75
76
77
78
79
80
81
82
83
84
85
86struct synaptics_rmi4_fn_desc {
87 unsigned char query_base_addr;
88 unsigned char cmd_base_addr;
89 unsigned char ctrl_base_addr;
90 unsigned char data_base_addr;
91 unsigned char intr_src_count;
92 unsigned char fn_number;
93};
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109struct synaptics_rmi4_fn {
110 unsigned char fn_number;
111 unsigned char num_of_data_sources;
112 unsigned char num_of_data_points;
113 unsigned char size_of_data_register_block;
114 unsigned char index_to_intr_reg;
115 unsigned char intr_mask;
116 struct synaptics_rmi4_fn_desc fn_desc;
117 struct list_head link;
118};
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136struct synaptics_rmi4_device_info {
137 unsigned int version_major;
138 unsigned int version_minor;
139 unsigned char manufacturer_id;
140 unsigned char product_props;
141 unsigned char product_info[2];
142 unsigned char date_code[3];
143 unsigned short tester_id;
144 unsigned short serial_number;
145 unsigned char product_id_string[11];
146 struct list_head support_fn_list;
147};
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171struct synaptics_rmi4_data {
172 struct synaptics_rmi4_device_info rmi4_mod_info;
173 struct input_dev *input_dev;
174 struct i2c_client *i2c_client;
175 const struct synaptics_rmi4_platform_data *board;
176 struct mutex fn_list_mutex;
177 struct mutex rmi4_page_mutex;
178 int current_page;
179 unsigned int number_of_interrupt_register;
180 unsigned short fn01_ctrl_base_addr;
181 unsigned short fn01_query_base_addr;
182 unsigned short fn01_data_base_addr;
183 int sensor_max_x;
184 int sensor_max_y;
185 struct regulator *regulator;
186 wait_queue_head_t wait;
187 bool touch_stopped;
188 unsigned char fingers_supported;
189};
190
191
192
193
194
195
196
197
198static int synaptics_rmi4_set_page(struct synaptics_rmi4_data *pdata,
199 unsigned int address)
200{
201 unsigned char txbuf[PAGE_LEN];
202 int retval;
203 unsigned int page;
204 struct i2c_client *i2c = pdata->i2c_client;
205
206 page = ((address >> 8) & MASK_8BIT);
207 if (page != pdata->current_page) {
208 txbuf[0] = MASK_8BIT;
209 txbuf[1] = page;
210 retval = i2c_master_send(i2c, txbuf, PAGE_LEN);
211 if (retval != PAGE_LEN)
212 dev_err(&i2c->dev, "%s:failed:%d\n", __func__, retval);
213 else
214 pdata->current_page = page;
215 } else
216 retval = PAGE_LEN;
217 return retval;
218}
219
220
221
222
223
224
225
226
227
228static int synaptics_rmi4_i2c_block_read(struct synaptics_rmi4_data *pdata,
229 unsigned short address,
230 unsigned char *valp, int size)
231{
232 int retval = 0;
233 int retry_count = 0;
234 int index;
235 struct i2c_client *i2c = pdata->i2c_client;
236
237 mutex_lock(&(pdata->rmi4_page_mutex));
238 retval = synaptics_rmi4_set_page(pdata, address);
239 if (retval != PAGE_LEN)
240 goto exit;
241 index = address & MASK_8BIT;
242retry:
243 retval = i2c_smbus_read_i2c_block_data(i2c, index, size, valp);
244 if (retval != size) {
245 if (++retry_count == MAX_RETRY_COUNT)
246 dev_err(&i2c->dev,
247 "%s:address 0x%04x size %d failed:%d\n",
248 __func__, address, size, retval);
249 else {
250 synaptics_rmi4_set_page(pdata, address);
251 goto retry;
252 }
253 }
254exit:
255 mutex_unlock(&(pdata->rmi4_page_mutex));
256 return retval;
257}
258
259
260
261
262
263
264
265
266
267static int synaptics_rmi4_i2c_byte_write(struct synaptics_rmi4_data *pdata,
268 unsigned short address,
269 unsigned char data)
270{
271 unsigned char txbuf[2];
272 int retval = 0;
273 struct i2c_client *i2c = pdata->i2c_client;
274
275
276 mutex_lock(&(pdata->rmi4_page_mutex));
277
278 retval = synaptics_rmi4_set_page(pdata, address);
279 if (retval != PAGE_LEN)
280 goto exit;
281 txbuf[0] = address & MASK_8BIT;
282 txbuf[1] = data;
283 retval = i2c_master_send(pdata->i2c_client, txbuf, 2);
284
285 if (retval != 2) {
286 dev_err(&i2c->dev, "%s:failed:%d\n", __func__, retval);
287 retval = -EIO;
288 } else
289 retval = 1;
290exit:
291 mutex_unlock(&(pdata->rmi4_page_mutex));
292 return retval;
293}
294
295
296
297
298
299
300
301
302static int synpatics_rmi4_touchpad_report(struct synaptics_rmi4_data *pdata,
303 struct synaptics_rmi4_fn *rfi)
304{
305
306 int touch_count = 0;
307 int finger;
308 int finger_registers;
309 int reg;
310 int finger_shift;
311 int finger_status;
312 int retval;
313 int x, y;
314 int wx, wy;
315 unsigned short data_base_addr;
316 unsigned short data_offset;
317 unsigned char data_reg_blk_size;
318 unsigned char values[2];
319 unsigned char data[DATA_LEN];
320 unsigned char fingers_supported = pdata->fingers_supported;
321 struct i2c_client *client = pdata->i2c_client;
322 struct input_dev *input_dev = pdata->input_dev;
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337 finger_registers = (fingers_supported + 3)/4;
338 data_base_addr = rfi->fn_desc.data_base_addr;
339 retval = synaptics_rmi4_i2c_block_read(pdata, data_base_addr, values,
340 finger_registers);
341 if (retval != finger_registers) {
342 dev_err(&client->dev, "%s:read status registers failed\n",
343 __func__);
344 return 0;
345 }
346
347
348
349
350 data_reg_blk_size = rfi->size_of_data_register_block;
351 for (finger = 0; finger < fingers_supported; finger++) {
352
353 reg = finger/4;
354
355 finger_shift = (finger % 4) * 2;
356 finger_status = (values[reg] >> finger_shift) & 3;
357
358
359
360
361 input_mt_slot(input_dev, finger);
362 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
363 finger_status != 0);
364
365 if (finger_status) {
366
367 data_offset = data_base_addr +
368 ((finger * data_reg_blk_size) +
369 finger_registers);
370 retval = synaptics_rmi4_i2c_block_read(pdata,
371 data_offset, data,
372 data_reg_blk_size);
373 if (retval != data_reg_blk_size) {
374 dev_err(&client->dev, "%s:read data failed\n",
375 __func__);
376 return 0;
377 }
378 x = (data[0] << 4) | (data[2] & MASK_4BIT);
379 y = (data[1] << 4) | ((data[2] >> 4) & MASK_4BIT);
380 wy = (data[3] >> 4) & MASK_4BIT;
381 wx = (data[3] & MASK_4BIT);
382
383 if (pdata->board->x_flip)
384 x = pdata->sensor_max_x - x;
385 if (pdata->board->y_flip)
386 y = pdata->sensor_max_y - y;
387
388 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
389 max(wx, wy));
390 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
391 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
392
393
394 touch_count++;
395 }
396 }
397
398
399 input_mt_sync_frame(input_dev);
400 input_sync(input_dev);
401
402 return touch_count;
403}
404
405
406
407
408
409
410
411
412static int synaptics_rmi4_report_device(struct synaptics_rmi4_data *pdata,
413 struct synaptics_rmi4_fn *rfi)
414{
415 int touch = 0;
416 struct i2c_client *client = pdata->i2c_client;
417 static int num_error_reports;
418 if (rfi->fn_number != SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM) {
419 num_error_reports++;
420 if (num_error_reports < MAX_ERROR_REPORT)
421 dev_err(&client->dev, "%s:report not supported\n",
422 __func__);
423 } else
424 touch = synpatics_rmi4_touchpad_report(pdata, rfi);
425 return touch;
426}
427
428
429
430
431
432
433
434static int synaptics_rmi4_sensor_report(struct synaptics_rmi4_data *pdata)
435{
436 unsigned char intr_status[4];
437
438 int touch = 0;
439 unsigned int retval;
440 struct synaptics_rmi4_fn *rfi;
441 struct synaptics_rmi4_device_info *rmi;
442 struct i2c_client *client = pdata->i2c_client;
443
444
445
446
447
448
449 retval = synaptics_rmi4_i2c_block_read(pdata,
450 pdata->fn01_data_base_addr + 1,
451 intr_status,
452 pdata->number_of_interrupt_register);
453 if (retval != pdata->number_of_interrupt_register) {
454 dev_err(&client->dev,
455 "could not read interrupt status registers\n");
456 return 0;
457 }
458
459
460
461
462
463 rmi = &(pdata->rmi4_mod_info);
464 list_for_each_entry(rfi, &rmi->support_fn_list, link) {
465 if (rfi->num_of_data_sources) {
466 if (intr_status[rfi->index_to_intr_reg] &
467 rfi->intr_mask)
468 touch = synaptics_rmi4_report_device(pdata,
469 rfi);
470 }
471 }
472
473 return touch;
474}
475
476
477
478
479
480
481
482
483
484static irqreturn_t synaptics_rmi4_irq(int irq, void *data)
485{
486 struct synaptics_rmi4_data *pdata = data;
487 int touch_count;
488 do {
489 touch_count = synaptics_rmi4_sensor_report(pdata);
490 if (touch_count)
491 wait_event_timeout(pdata->wait, pdata->touch_stopped,
492 msecs_to_jiffies(1));
493 else
494 break;
495 } while (!pdata->touch_stopped);
496 return IRQ_HANDLED;
497}
498
499
500
501
502
503
504
505
506
507
508static int synpatics_rmi4_touchpad_detect(struct synaptics_rmi4_data *pdata,
509 struct synaptics_rmi4_fn *rfi,
510 struct synaptics_rmi4_fn_desc *fd,
511 unsigned int interruptcount)
512{
513 unsigned char queries[QUERY_LEN];
514 unsigned short intr_offset;
515 unsigned char abs_data_size;
516 unsigned char abs_data_blk_size;
517 unsigned char egr_0, egr_1;
518 unsigned int all_data_blk_size;
519 int has_pinch, has_flick, has_tap;
520 int has_tapandhold, has_doubletap;
521 int has_earlytap, has_press;
522 int has_palmdetect, has_rotate;
523 int has_rel;
524 int i;
525 int retval;
526 struct i2c_client *client = pdata->i2c_client;
527
528 rfi->fn_desc.query_base_addr = fd->query_base_addr;
529 rfi->fn_desc.data_base_addr = fd->data_base_addr;
530 rfi->fn_desc.intr_src_count = fd->intr_src_count;
531 rfi->fn_desc.fn_number = fd->fn_number;
532 rfi->fn_number = fd->fn_number;
533 rfi->num_of_data_sources = fd->intr_src_count;
534 rfi->fn_desc.ctrl_base_addr = fd->ctrl_base_addr;
535 rfi->fn_desc.cmd_base_addr = fd->cmd_base_addr;
536
537
538
539
540
541
542 retval = synaptics_rmi4_i2c_block_read(pdata, fd->query_base_addr,
543 queries,
544 sizeof(queries));
545 if (retval != sizeof(queries)) {
546 dev_err(&client->dev, "%s:read function query registers\n",
547 __func__);
548 return retval;
549 }
550
551
552
553
554 if ((queries[1] & MASK_3BIT) <= 4)
555
556 rfi->num_of_data_points = (queries[1] & MASK_3BIT) + 1;
557 else {
558
559
560
561
562 if ((queries[1] & MASK_3BIT) == 5)
563 rfi->num_of_data_points = 10;
564 }
565 pdata->fingers_supported = rfi->num_of_data_points;
566
567 rfi->index_to_intr_reg = (interruptcount + 7)/8;
568 if (rfi->index_to_intr_reg != 0)
569 rfi->index_to_intr_reg -= 1;
570
571
572
573
574 intr_offset = interruptcount % 8;
575 rfi->intr_mask = 0;
576 for (i = intr_offset;
577 i < ((fd->intr_src_count & MASK_3BIT) + intr_offset); i++)
578 rfi->intr_mask |= 1 << i;
579
580
581 abs_data_size = queries[5] & MASK_2BIT;
582
583 abs_data_blk_size = 3 + (2 * (abs_data_size == 0 ? 1 : 0));
584 rfi->size_of_data_register_block = abs_data_blk_size;
585
586
587
588
589
590
591 egr_0 = queries[7];
592 egr_1 = queries[8];
593
594
595
596
597
598 has_pinch = egr_0 & HAS_PINCH;
599 has_flick = egr_0 & HAS_FLICK;
600 has_tap = egr_0 & HAS_TAP;
601 has_earlytap = egr_0 & HAS_EARLYTAP;
602 has_press = egr_0 & HAS_PRESS;
603 has_rotate = egr_1 & HAS_ROTATE;
604 has_rel = queries[1] & HAS_RELEASE;
605 has_tapandhold = egr_0 & HAS_TAPANDHOLD;
606 has_doubletap = egr_0 & HAS_DOUBLETAP;
607 has_palmdetect = egr_1 & HAS_PALMDETECT;
608
609
610
611
612
613 all_data_blk_size =
614
615 ((rfi->num_of_data_points + 3) / 4) +
616
617 (abs_data_blk_size * rfi->num_of_data_points) +
618
619
620
621 2 * has_rel +
622
623
624
625
626 !!(egr_0) +
627
628
629
630
631 (egr_0 || egr_1) +
632
633
634
635
636 !!(has_pinch | has_flick) +
637
638
639
640
641 2 * !!(has_flick);
642 return retval;
643}
644
645
646
647
648
649
650
651
652static int synaptics_rmi4_touchpad_config(struct synaptics_rmi4_data *pdata,
653 struct synaptics_rmi4_fn *rfi)
654{
655
656
657
658
659 unsigned char data[BUF_LEN];
660 int retval = 0;
661 struct i2c_client *client = pdata->i2c_client;
662
663
664
665
666
667 retval = synaptics_rmi4_i2c_block_read(pdata,
668 rfi->fn_desc.query_base_addr,
669 data, QUERY_LEN);
670 if (retval != QUERY_LEN)
671 dev_err(&client->dev, "%s:read query registers failed\n",
672 __func__);
673 else {
674 retval = synaptics_rmi4_i2c_block_read(pdata,
675 rfi->fn_desc.ctrl_base_addr,
676 data, DATA_BUF_LEN);
677 if (retval != DATA_BUF_LEN) {
678 dev_err(&client->dev,
679 "%s:read control registers failed\n",
680 __func__);
681 return retval;
682 }
683
684 pdata->sensor_max_x = ((data[6] & MASK_8BIT) << 0) |
685 ((data[7] & MASK_4BIT) << 8);
686 pdata->sensor_max_y = ((data[8] & MASK_5BIT) << 0) |
687 ((data[9] & MASK_4BIT) << 8);
688 }
689 return retval;
690}
691
692
693
694
695
696
697
698static int synaptics_rmi4_i2c_query_device(struct synaptics_rmi4_data *pdata)
699{
700 int i;
701 int retval;
702 unsigned char std_queries[STD_QUERY_LEN];
703 unsigned char intr_count = 0;
704 int data_sources = 0;
705 unsigned int ctrl_offset;
706 struct synaptics_rmi4_fn *rfi;
707 struct synaptics_rmi4_fn_desc rmi_fd;
708 struct synaptics_rmi4_device_info *rmi;
709 struct i2c_client *client = pdata->i2c_client;
710
711
712
713
714
715 INIT_LIST_HEAD(&pdata->rmi4_mod_info.support_fn_list);
716
717
718
719
720
721 for (i = PDT_START_SCAN_LOCATION; i > PDT_END_SCAN_LOCATION;
722 i -= PDT_ENTRY_SIZE) {
723 retval = synaptics_rmi4_i2c_block_read(pdata, i,
724 (unsigned char *)&rmi_fd,
725 sizeof(rmi_fd));
726 if (retval != sizeof(rmi_fd)) {
727
728 dev_err(&client->dev, "%s: read error\n", __func__);
729 return -EIO;
730 }
731 rfi = NULL;
732 if (rmi_fd.fn_number) {
733 switch (rmi_fd.fn_number & MASK_8BIT) {
734 case SYNAPTICS_RMI4_DEVICE_CONTROL_FUNC_NUM:
735 pdata->fn01_query_base_addr =
736 rmi_fd.query_base_addr;
737 pdata->fn01_ctrl_base_addr =
738 rmi_fd.ctrl_base_addr;
739 pdata->fn01_data_base_addr =
740 rmi_fd.data_base_addr;
741 break;
742 case SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM:
743 if (rmi_fd.intr_src_count) {
744 rfi = kmalloc(sizeof(*rfi),
745 GFP_KERNEL);
746 if (!rfi)
747 return -ENOMEM;
748 retval = synpatics_rmi4_touchpad_detect
749 (pdata, rfi,
750 &rmi_fd,
751 intr_count);
752 if (retval < 0) {
753 kfree(rfi);
754 return retval;
755 }
756 }
757 break;
758 }
759
760 intr_count += (rmi_fd.intr_src_count & MASK_3BIT);
761
762
763
764
765 if (rfi && rmi_fd.intr_src_count) {
766
767 mutex_lock(&(pdata->fn_list_mutex));
768 list_add_tail(&rfi->link,
769 &pdata->rmi4_mod_info.support_fn_list);
770 mutex_unlock(&(pdata->fn_list_mutex));
771 }
772 } else {
773
774
775
776
777 dev_dbg(&client->dev,
778 "%s:end of PDT\n", __func__);
779 break;
780 }
781 }
782
783
784
785
786 pdata->number_of_interrupt_register = (intr_count + 7) / 8;
787
788
789
790
791
792
793
794
795 retval = synaptics_rmi4_i2c_block_read(pdata,
796 pdata->fn01_query_base_addr,
797 std_queries,
798 sizeof(std_queries));
799 if (retval != sizeof(std_queries)) {
800 dev_err(&client->dev, "%s:Failed reading queries\n",
801 __func__);
802 return -EIO;
803 }
804
805
806 pdata->rmi4_mod_info.version_major = 4;
807 pdata->rmi4_mod_info.version_minor = 0;
808
809
810
811
812 pdata->rmi4_mod_info.manufacturer_id = std_queries[0];
813 pdata->rmi4_mod_info.product_props = std_queries[1];
814 pdata->rmi4_mod_info.product_info[0] = std_queries[2];
815 pdata->rmi4_mod_info.product_info[1] = std_queries[3];
816
817 pdata->rmi4_mod_info.date_code[0] = std_queries[4] & MASK_5BIT;
818
819 pdata->rmi4_mod_info.date_code[1] = std_queries[5] & MASK_4BIT;
820
821 pdata->rmi4_mod_info.date_code[2] = std_queries[6] & MASK_5BIT;
822 pdata->rmi4_mod_info.tester_id = ((std_queries[7] & MASK_7BIT) << 8) |
823 (std_queries[8] & MASK_7BIT);
824 pdata->rmi4_mod_info.serial_number =
825 ((std_queries[9] & MASK_7BIT) << 8) |
826 (std_queries[10] & MASK_7BIT);
827 memcpy(pdata->rmi4_mod_info.product_id_string, &std_queries[11], 10);
828
829
830 if (pdata->rmi4_mod_info.manufacturer_id != 1)
831 dev_err(&client->dev, "%s: non-Synaptics mfg id:%d\n",
832 __func__, pdata->rmi4_mod_info.manufacturer_id);
833
834 list_for_each_entry(rfi, &pdata->rmi4_mod_info.support_fn_list, link)
835 data_sources += rfi->num_of_data_sources;
836 if (data_sources) {
837 rmi = &(pdata->rmi4_mod_info);
838 list_for_each_entry(rfi, &rmi->support_fn_list, link) {
839 if (rfi->num_of_data_sources) {
840 if (rfi->fn_number ==
841 SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM) {
842 retval = synaptics_rmi4_touchpad_config
843 (pdata, rfi);
844 if (retval < 0)
845 return retval;
846 } else
847 dev_err(&client->dev,
848 "%s:fn_number not supported\n",
849 __func__);
850
851
852
853
854 ctrl_offset = pdata->fn01_ctrl_base_addr + 1 +
855 rfi->index_to_intr_reg;
856 retval = synaptics_rmi4_i2c_byte_write(pdata,
857 ctrl_offset,
858 rfi->intr_mask);
859 if (retval < 0)
860 return retval;
861 }
862 }
863 }
864 return 0;
865}
866
867
868
869
870
871static struct synaptics_rmi4_platform_data synaptics_rmi4_platformdata = {
872 .irq_type = (IRQF_TRIGGER_FALLING | IRQF_SHARED),
873 .x_flip = false,
874 .y_flip = true,
875};
876
877
878
879
880
881
882
883
884
885
886
887
888static int synaptics_rmi4_probe
889 (struct i2c_client *client, const struct i2c_device_id *dev_id)
890{
891 int retval;
892 unsigned char intr_status[4];
893 struct synaptics_rmi4_data *rmi4_data;
894 const struct synaptics_rmi4_platform_data *platformdata =
895 client->dev.platform_data;
896
897 if (!i2c_check_functionality(client->adapter,
898 I2C_FUNC_SMBUS_BYTE_DATA)) {
899 dev_err(&client->dev, "i2c smbus byte data not supported\n");
900 return -EIO;
901 }
902
903 if (!platformdata)
904 platformdata = &synaptics_rmi4_platformdata;
905
906
907 rmi4_data = kcalloc(2, sizeof(struct synaptics_rmi4_data),
908 GFP_KERNEL);
909 if (!rmi4_data)
910 return -ENOMEM;
911
912 rmi4_data->input_dev = input_allocate_device();
913 if (rmi4_data->input_dev == NULL) {
914 retval = -ENOMEM;
915 goto err_input;
916 }
917
918 rmi4_data->regulator = regulator_get(&client->dev, "vdd");
919 if (IS_ERR(rmi4_data->regulator)) {
920 dev_err(&client->dev, "%s:get regulator failed\n",
921 __func__);
922 retval = PTR_ERR(rmi4_data->regulator);
923 goto err_get_regulator;
924 }
925 retval = regulator_enable(rmi4_data->regulator);
926 if (retval < 0) {
927 dev_err(&client->dev, "%s:regulator enable failed\n",
928 __func__);
929 goto err_regulator_enable;
930 }
931 init_waitqueue_head(&rmi4_data->wait);
932
933
934
935
936 rmi4_data->i2c_client = client;
937
938 rmi4_data->current_page = MASK_16BIT;
939 rmi4_data->board = platformdata;
940 rmi4_data->touch_stopped = false;
941
942
943 mutex_init(&(rmi4_data->fn_list_mutex));
944 mutex_init(&(rmi4_data->rmi4_page_mutex));
945
946
947
948
949
950
951 retval = synaptics_rmi4_i2c_query_device(rmi4_data);
952 if (retval) {
953 dev_err(&client->dev, "%s: rmi4 query device failed\n",
954 __func__);
955 goto err_query_dev;
956 }
957
958
959 i2c_set_clientdata(client, rmi4_data);
960
961
962 rmi4_data->input_dev->name = DRIVER_NAME;
963 rmi4_data->input_dev->phys = "Synaptics_Clearpad";
964 rmi4_data->input_dev->id.bustype = BUS_I2C;
965 rmi4_data->input_dev->dev.parent = &client->dev;
966 input_set_drvdata(rmi4_data->input_dev, rmi4_data);
967
968
969 set_bit(EV_SYN, rmi4_data->input_dev->evbit);
970 set_bit(EV_KEY, rmi4_data->input_dev->evbit);
971 set_bit(EV_ABS, rmi4_data->input_dev->evbit);
972
973 input_set_abs_params(rmi4_data->input_dev, ABS_MT_POSITION_X, 0,
974 rmi4_data->sensor_max_x, 0, 0);
975 input_set_abs_params(rmi4_data->input_dev, ABS_MT_POSITION_Y, 0,
976 rmi4_data->sensor_max_y, 0, 0);
977 input_set_abs_params(rmi4_data->input_dev, ABS_MT_TOUCH_MAJOR, 0,
978 MAX_TOUCH_MAJOR, 0, 0);
979 input_mt_init_slots(rmi4_data->input_dev,
980 rmi4_data->fingers_supported, 0);
981
982
983 synaptics_rmi4_i2c_block_read(rmi4_data,
984 rmi4_data->fn01_data_base_addr + 1, intr_status,
985 rmi4_data->number_of_interrupt_register);
986 retval = request_threaded_irq(client->irq, NULL,
987 synaptics_rmi4_irq,
988 platformdata->irq_type,
989 DRIVER_NAME, rmi4_data);
990 if (retval) {
991 dev_err(&client->dev, "%s:Unable to get attn irq %d\n",
992 __func__, client->irq);
993 goto err_query_dev;
994 }
995
996 retval = input_register_device(rmi4_data->input_dev);
997 if (retval) {
998 dev_err(&client->dev, "%s:input register failed\n", __func__);
999 goto err_free_irq;
1000 }
1001
1002 return retval;
1003
1004err_free_irq:
1005 free_irq(client->irq, rmi4_data);
1006err_query_dev:
1007 regulator_disable(rmi4_data->regulator);
1008err_regulator_enable:
1009 regulator_put(rmi4_data->regulator);
1010err_get_regulator:
1011 input_free_device(rmi4_data->input_dev);
1012 rmi4_data->input_dev = NULL;
1013err_input:
1014 kfree(rmi4_data);
1015
1016 return retval;
1017}
1018
1019
1020
1021
1022
1023
1024
1025static int synaptics_rmi4_remove(struct i2c_client *client)
1026{
1027 struct synaptics_rmi4_data *rmi4_data = i2c_get_clientdata(client);
1028
1029 rmi4_data->touch_stopped = true;
1030 wake_up(&rmi4_data->wait);
1031 free_irq(client->irq, rmi4_data);
1032 input_unregister_device(rmi4_data->input_dev);
1033 regulator_disable(rmi4_data->regulator);
1034 regulator_put(rmi4_data->regulator);
1035 kfree(rmi4_data);
1036
1037 return 0;
1038}
1039
1040#ifdef CONFIG_PM
1041
1042
1043
1044
1045
1046
1047
1048static int synaptics_rmi4_suspend(struct device *dev)
1049{
1050
1051 int retval;
1052 unsigned char intr_status;
1053 struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
1054
1055 rmi4_data->touch_stopped = true;
1056 disable_irq(rmi4_data->i2c_client->irq);
1057
1058 retval = synaptics_rmi4_i2c_block_read(rmi4_data,
1059 rmi4_data->fn01_data_base_addr + 1,
1060 &intr_status,
1061 rmi4_data->number_of_interrupt_register);
1062 if (retval < 0)
1063 return retval;
1064
1065 retval = synaptics_rmi4_i2c_byte_write(rmi4_data,
1066 rmi4_data->fn01_ctrl_base_addr + 1,
1067 (intr_status & ~TOUCHPAD_CTRL_INTR));
1068 if (retval < 0)
1069 return retval;
1070
1071 regulator_disable(rmi4_data->regulator);
1072
1073 return 0;
1074}
1075
1076
1077
1078
1079
1080
1081
1082static int synaptics_rmi4_resume(struct device *dev)
1083{
1084 int retval;
1085 unsigned char intr_status;
1086 struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
1087
1088 retval = regulator_enable(rmi4_data->regulator);
1089 if (retval) {
1090 dev_err(dev, "Regulator enable failed (%d)\n", retval);
1091 return retval;
1092 }
1093
1094 enable_irq(rmi4_data->i2c_client->irq);
1095 rmi4_data->touch_stopped = false;
1096
1097 retval = synaptics_rmi4_i2c_block_read(rmi4_data,
1098 rmi4_data->fn01_data_base_addr + 1,
1099 &intr_status,
1100 rmi4_data->number_of_interrupt_register);
1101 if (retval < 0)
1102 return retval;
1103
1104 retval = synaptics_rmi4_i2c_byte_write(rmi4_data,
1105 rmi4_data->fn01_ctrl_base_addr + 1,
1106 (intr_status | TOUCHPAD_CTRL_INTR));
1107 if (retval < 0)
1108 return retval;
1109
1110 return 0;
1111}
1112
1113static const struct dev_pm_ops synaptics_rmi4_dev_pm_ops = {
1114 .suspend = synaptics_rmi4_suspend,
1115 .resume = synaptics_rmi4_resume,
1116};
1117#endif
1118
1119static const struct i2c_device_id synaptics_rmi4_id_table[] = {
1120 { DRIVER_NAME, 0 },
1121 { },
1122};
1123MODULE_DEVICE_TABLE(i2c, synaptics_rmi4_id_table);
1124
1125static struct i2c_driver synaptics_rmi4_driver = {
1126 .driver = {
1127 .name = DRIVER_NAME,
1128 .owner = THIS_MODULE,
1129#ifdef CONFIG_PM
1130 .pm = &synaptics_rmi4_dev_pm_ops,
1131#endif
1132 },
1133 .probe = synaptics_rmi4_probe,
1134 .remove = synaptics_rmi4_remove,
1135 .id_table = synaptics_rmi4_id_table,
1136};
1137
1138module_i2c_driver(synaptics_rmi4_driver);
1139
1140MODULE_LICENSE("GPL v2");
1141MODULE_AUTHOR("naveen.gaddipati@stericsson.com, js.ha@stericsson.com");
1142MODULE_DESCRIPTION("synaptics rmi4 i2c touch Driver");
1143MODULE_ALIAS("i2c:synaptics_rmi4_ts");
1144