3 #include "tpd_custom_gt9xx.h"
5 #include "cust_gpio_usage.h"
8 #include <linux/hwmsensor.h>
9 #include <linux/hwmsen_dev.h>
10 #include <linux/sensors_io.h>
13 #include <linux/mmprofile.h>
14 #include <linux/device.h>
15 #include <linux/proc_fs.h> /*proc*/
16 extern struct tpd_device
*tpd
;
17 #ifdef VELOCITY_CUSTOM
18 extern int tpd_v_magnify_x
;
19 extern int tpd_v_magnify_y
;
21 static int tpd_flag
= 0;
22 static int tpd_halt
= 0;
23 static int tpd_eint_mode
=1;
24 static int tpd_polling_time
=50;
25 static DECLARE_WAIT_QUEUE_HEAD(waiter
);
26 static DEFINE_MUTEX(i2c_access
);
28 #ifdef TPD_HAVE_BUTTON
29 static int tpd_keys_local
[TPD_KEY_COUNT
] = TPD_KEYS
;
30 static int tpd_keys_dim_local
[TPD_KEY_COUNT
][4] = TPD_KEYS_DIM
;
33 #if GTP_HAVE_TOUCH_KEY
34 const u16 touch_key_array
[] = TPD_KEYS
;
35 //#define GTP_MAX_KEY_NUM ( sizeof( touch_key_array )/sizeof( touch_key_array[0] ) )
36 struct touch_vitual_key_map_t
41 static struct touch_vitual_key_map_t touch_key_point_maping_array
[]=GTP_KEY_MAP_ARRAY
;
44 #if (defined(TPD_WARP_START) && defined(TPD_WARP_END))
45 static int tpd_wb_start_local
[TPD_WARP_CNT
] = TPD_WARP_START
;
46 static int tpd_wb_end_local
[TPD_WARP_CNT
] = TPD_WARP_END
;
49 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
50 //static int tpd_calmat_local[8] = TPD_CALIBRATION_MATRIX;
51 //static int tpd_def_calmat_local[8] = TPD_CALIBRATION_MATRIX;
52 static int tpd_def_calmat_local_normal
[8] = TPD_CALIBRATION_MATRIX_ROTATION_NORMAL
;
53 static int tpd_def_calmat_local_factory
[8] = TPD_CALIBRATION_MATRIX_ROTATION_FACTORY
;
56 s32
gtp_send_cfg(struct i2c_client
*client
);
57 static void tpd_eint_interrupt_handler(void);
58 static int touch_event_handler(void *unused
);
59 static int tpd_i2c_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
);
60 static int tpd_i2c_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
61 static int tpd_i2c_remove(struct i2c_client
*client
);
62 static void tpd_on(void);
63 static void tpd_off(void);
65 #if GTP_CREATE_WR_NODE
66 extern s32
init_wr_node(struct i2c_client
*);
67 extern void uninit_wr_node(void);
70 #ifdef GTP_CHARGER_DETECT
71 extern bool upmu_get_pchr_chrdet(void);
72 #define TPD_CHARGER_CHECK_CIRCLE 50
73 static struct delayed_work gtp_charger_check_work
;
74 static struct workqueue_struct
*gtp_charger_check_workqueue
= NULL
;
75 static void gtp_charger_check_func(struct work_struct
*);
76 static u8 gtp_charger_mode
= 0;
80 #define TPD_ESD_CHECK_CIRCLE 2000
81 static struct delayed_work gtp_esd_check_work
;
82 static struct workqueue_struct
*gtp_esd_check_workqueue
= NULL
;
83 static void gtp_esd_check_func(struct work_struct
*);
87 #define TPD_PROXIMITY_VALID_REG 0x814E
88 #define TPD_PROXIMITY_ENABLE_REG 0x8042
89 static u8 tpd_proximity_flag
= 0;
90 static u8 tpd_proximity_detect
= 1;//0-->close ; 1--> far away
93 #ifndef GTP_REG_REFRESH_RATE
94 #define GTP_REG_REFRESH_RATE 0x8056
97 struct i2c_client
*i2c_client_point
= NULL
;
98 static const struct i2c_device_id tpd_i2c_id
[] = {{"gt9xx", 0}, {}};
99 static unsigned short force
[] = {0, 0xBA, I2C_CLIENT_END
, I2C_CLIENT_END
};
100 static const unsigned short *const forces
[] = { force
, NULL
};
101 //static struct i2c_client_address_data addr_data = { .forces = forces,};
102 static struct i2c_board_info __initdata i2c_tpd
= { I2C_BOARD_INFO("gt9xx", (0xBA >> 1))};
103 static struct i2c_driver tpd_i2c_driver
=
105 .probe
= tpd_i2c_probe
,
106 .remove
= tpd_i2c_remove
,
107 .detect
= tpd_i2c_detect
,
108 .driver
.name
= "gt9xx",
109 .id_table
= tpd_i2c_id
,
110 .address_list
= (const unsigned short *) forces
,
113 static u8 config
[GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
]
114 = {GTP_REG_CONFIG_DATA
>> 8, GTP_REG_CONFIG_DATA
& 0xff};
115 #ifdef GTP_CHARGER_DETECT
116 static u8 config_charger
[GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
]
117 = {GTP_REG_CONFIG_DATA
>> 8, GTP_REG_CONFIG_DATA
& 0xff};
122 u16 pid
; //product id //
123 u16 vid
; //version id //
127 st_tpd_info tpd_info
;
131 u8 gtp_rawdiff_mode
= 0;
134 /* proc file system */
135 s32
i2c_read_bytes(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
);
136 s32
i2c_write_bytes(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, int len
);
137 static struct proc_dir_entry
*gt91xx_config_proc
= NULL
;
139 /*******************************************************
144 rate: refresh rate N (Duration=5+N ms, N=0~15)
147 Executive outcomes.0---succeed.
148 *******************************************************/
149 static u8
gtp_set_refresh_rate(u8 rate
)
151 u8 buf
[3] = {GTP_REG_REFRESH_RATE
>>8, GTP_REG_REFRESH_RATE
& 0xff, rate
};
155 GTP_ERROR("Refresh rate is over range (%d)", rate
);
159 GTP_INFO("Refresh rate change to %d", rate
);
160 return gtp_i2c_write(i2c_client_point
, buf
, sizeof(buf
));
163 /*******************************************************
168 Refresh rate or error code
169 *******************************************************/
170 static u8
gtp_get_refresh_rate(void)
174 u8 buf
[3] = {GTP_REG_REFRESH_RATE
>>8, GTP_REG_REFRESH_RATE
& 0xff};
175 ret
= gtp_i2c_read(i2c_client_point
, buf
, sizeof(buf
));
179 GTP_INFO("Refresh rate is %d", buf
[GTP_ADDR_LENGTH
]);
180 return buf
[GTP_ADDR_LENGTH
];
183 //=============================================================
184 static ssize_t
show_refresh_rate(struct device
*dev
,struct device_attribute
*attr
, char *buf
)
186 int ret
= gtp_get_refresh_rate();
190 return sprintf(buf
, "%d\n", ret
);
192 static ssize_t
store_refresh_rate(struct device
*dev
,struct device_attribute
*attr
, const char *buf
, size_t size
)
195 gtp_set_refresh_rate(simple_strtoul(buf
, NULL
, 16));
198 static DEVICE_ATTR(tpd_refresh_rate
, 0664, show_refresh_rate
, store_refresh_rate
);
200 static struct device_attribute
*gt9xx_attrs
[] =
202 &dev_attr_tpd_refresh_rate
,
204 //=============================================================
206 static int tpd_i2c_detect(struct i2c_client
*client
, struct i2c_board_info
*info
)
208 strcpy(info
->type
, "mtk-tpd");
213 static s32
tpd_get_ps_value(void)
215 return tpd_proximity_detect
;
218 static s32
tpd_enable_ps(s32 enable
)
226 tpd_proximity_flag
= 1;
227 GTP_INFO("TPD proximity function to be on.");
232 tpd_proximity_flag
= 0;
233 GTP_INFO("TPD proximity function to be off.");
236 ret
= i2c_write_bytes(i2c_client_point
, TPD_PROXIMITY_ENABLE_REG
, &state
, 1);
240 GTP_ERROR("TPD %s proximity cmd failed.", state
? "enable" : "disable");
244 GTP_INFO("TPD proximity function %s success.", state
? "enable" : "disable");
248 s32
tpd_ps_operate(void *self
, u32 command
, void *buff_in
, s32 size_in
,
249 void *buff_out
, s32 size_out
, s32
*actualout
)
253 hwm_sensor_data
*sensor_data
;
258 if ((buff_in
== NULL
) || (size_in
< sizeof(int)))
260 GTP_ERROR("Set delay parameter error!");
268 if ((buff_in
== NULL
) || (size_in
< sizeof(int)))
270 GTP_ERROR("Enable sensor parameter error!");
275 value
= *(int *)buff_in
;
276 err
= tpd_enable_ps(value
);
281 case SENSOR_GET_DATA
:
282 if ((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
284 GTP_ERROR("Get sensor data parameter error!");
289 sensor_data
= (hwm_sensor_data
*)buff_out
;
290 sensor_data
->values
[0] = tpd_get_ps_value();
291 sensor_data
->value_divide
= 1;
292 sensor_data
->status
= SENSOR_STATUS_ACCURACY_MEDIUM
;
298 GTP_ERROR("proxmy sensor operate function no this parameter %d!", command
);
307 static int gt91xx_config_read_proc(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
311 char temp_data
[GTP_CONFIG_MAX_LENGTH
+ 2] = {0};
312 int i
, len
, err
= -1;
314 page
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
322 ptr
+= sprintf(ptr
, "==== GT9XX config init value====\n");
324 for (i
= 0 ; i
< GTP_CONFIG_MAX_LENGTH
; i
++)
326 ptr
+= sprintf(ptr
, "0x%02X ", config
[i
+ 2]);
329 ptr
+= sprintf(ptr
, "\n");
332 ptr
+= sprintf(ptr
, "\n");
334 ptr
+= sprintf(ptr
, "==== GT9XX config real value====\n");
335 i2c_read_bytes(i2c_client_point
, GTP_REG_CONFIG_DATA
, temp_data
, GTP_CONFIG_MAX_LENGTH
);
337 for (i
= 0 ; i
< GTP_CONFIG_MAX_LENGTH
; i
++)
339 ptr
+= sprintf(ptr
, "0x%02X ", temp_data
[i
]);
342 ptr
+= sprintf(ptr
, "\n");
344 /* Touch PID & VID */
345 ptr
+= sprintf(ptr
, "\n");
346 ptr
+= sprintf(ptr
, "==== GT9XX Version ID ====\n");
347 i2c_read_bytes(i2c_client_point
, GTP_REG_VERSION
, temp_data
, 6);
348 ptr
+= sprintf(ptr
, "Chip PID: %c%c%c VID: 0x%02X%02X\n", temp_data
[0], temp_data
[1], temp_data
[2], temp_data
[5], temp_data
[4]);
349 ptr
+= sprintf(ptr
, "Driver VID: 0x%02X%02X\n", gtp_default_FW
[12], gtp_default_FW
[13]);
350 i2c_read_bytes(i2c_client_point
, 0x41E4, temp_data
, 1);
351 ptr
+= sprintf(ptr
, "Boot status 0x%X\n", temp_data
[0]);
353 /* Touch Status and Clock Gate */
354 ptr
+= sprintf(ptr
, "\n");
355 ptr
+= sprintf(ptr
, "==== Touch Status and Clock Gate ====\n");
356 ptr
+= sprintf(ptr
, "status: 1: on, 0 :off\n");
357 ptr
+= sprintf(ptr
, "status:%d\n", (tpd_halt
+1)&0x1);
366 err
= copy_to_user(buffer
,(char *)page
,len
);
376 //return (ptr - page);
379 static int gt91xx_config_write_proc(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
382 char temp
[25] = {0}; // for store special format cmd
383 char mode_str
[15] = {0};
387 GTP_DEBUG("write count %ld\n", (unsigned long)count
);
389 if (count
> GTP_CONFIG_MAX_LENGTH
)
391 GTP_ERROR("size not match [%d:%ld]", GTP_CONFIG_MAX_LENGTH
, (unsigned long)count
);
395 /**********************************************/
396 /* for store special format cmd */
397 if (copy_from_user(temp
, buffer
, sizeof(temp
)))
399 GTP_ERROR("copy from user fail 2");
402 sscanf(temp
, "%s %d", (char *)&mode_str
, &mode
);
404 /***********POLLING/EINT MODE switch****************/
405 if(strcmp(mode_str
, "polling") == 0)
407 if(mode
>=10&&mode
<=200)
409 GTP_INFO("Switch to polling mode, polling time is %d",mode
);
411 tpd_polling_time
=mode
;
413 wake_up_interruptible(&waiter
);
417 GTP_INFO("Wrong polling time, please set between 10~200ms");
421 if(strcmp(mode_str
, "eint") == 0)
423 GTP_INFO("Switch to eint mode");
427 /**********************************************/
428 if(strcmp(mode_str
, "switch") == 0)
430 if(mode
== 0)// turn off
432 else if(mode
== 1)//turn on
435 GTP_ERROR("error mode :%d", mode
);
439 if(strcmp(mode_str
, "clear_config") == 0)
441 GTP_INFO("Force clear config");
443 ret
= i2c_write_bytes(i2c_client_point
, GTP_REG_SLEEP
, buf
, 1);
447 if (copy_from_user(&config
[2], buffer
, count
))
449 GTP_ERROR("copy from user fail");
453 /***********clk operate reseved****************/
454 /**********************************************/
455 ret
= gtp_send_cfg(i2c_client_point
);
456 abs_x_max
= (config
[RESOLUTION_LOC
+ 1] << 8) + config
[RESOLUTION_LOC
];
457 abs_y_max
= (config
[RESOLUTION_LOC
+ 3] << 8) + config
[RESOLUTION_LOC
+ 2];
458 int_type
= (config
[TRIGGER_LOC
]) & 0x03;
462 GTP_ERROR("send config failed.");
468 int i2c_read_bytes(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
)
470 u8 buffer
[GTP_ADDR_LENGTH
];
474 struct i2c_msg msg
[2] =
477 .addr
= ((client
->addr
&I2C_MASK_FLAG
) | (I2C_ENEXT_FLAG
)),
478 //.addr = (client->addr &I2C_MASK_FLAG),
479 //.ext_flag = I2C_ENEXT_FLAG,
480 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
483 .len
= GTP_ADDR_LENGTH
,
484 .timing
= I2C_MASTER_CLOCK
487 .addr
= ((client
->addr
&I2C_MASK_FLAG
) | (I2C_ENEXT_FLAG
)),
488 //.addr = (client->addr &I2C_MASK_FLAG),
489 //.ext_flag = I2C_ENEXT_FLAG,
490 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
492 .timing
= I2C_MASTER_CLOCK
499 GTP_DEBUG("i2c_read_bytes to device %02X address %04X len %d", client
->addr
, addr
, len
);
503 buffer
[0] = ((addr
+ offset
) >> 8) & 0xFF;
504 buffer
[1] = (addr
+ offset
) & 0xFF;
506 msg
[1].buf
= &rxbuf
[offset
];
508 if (left
> MAX_TRANSACTION_LENGTH
)
510 msg
[1].len
= MAX_TRANSACTION_LENGTH
;
511 left
-= MAX_TRANSACTION_LENGTH
;
512 offset
+= MAX_TRANSACTION_LENGTH
;
520 if (i2c_transfer(client
->adapter
, &msg
[0], 2) != 2)
522 GTP_ERROR("I2C read 0x%X length=%d failed", addr
+ offset
, len
);
530 s32
gtp_i2c_read(struct i2c_client
*client
, u8
*buf
, s32 len
)
533 u16 addr
= (buf
[0] << 8) + buf
[1];
535 ret
= i2c_read_bytes(client
, addr
, &buf
[2], len
- 2);
543 gtp_reset_guitar(client
, 20);
548 int i2c_write_bytes(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, int len
)
550 u8 buffer
[MAX_TRANSACTION_LENGTH
];
556 .addr
= ((client
->addr
&I2C_MASK_FLAG
) | (I2C_ENEXT_FLAG
)),
557 //.addr = (client->addr &I2C_MASK_FLAG),
558 //.ext_flag = I2C_ENEXT_FLAG,
559 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
562 .timing
= I2C_MASTER_CLOCK
,
569 GTP_DEBUG("i2c_write_bytes to device %02X address %04X len %d", client
->addr
, addr
, len
);
573 buffer
[0] = ((addr
+ offset
) >> 8) & 0xFF;
574 buffer
[1] = (addr
+ offset
) & 0xFF;
576 if (left
> MAX_I2C_TRANSFER_SIZE
)
578 memcpy(&buffer
[GTP_ADDR_LENGTH
], &txbuf
[offset
], MAX_I2C_TRANSFER_SIZE
);
579 msg
.len
= MAX_TRANSACTION_LENGTH
;
580 left
-= MAX_I2C_TRANSFER_SIZE
;
581 offset
+= MAX_I2C_TRANSFER_SIZE
;
585 memcpy(&buffer
[GTP_ADDR_LENGTH
], &txbuf
[offset
], left
);
586 msg
.len
= left
+ GTP_ADDR_LENGTH
;
590 //GTP_DEBUG("byte left %d offset %d", left, offset);
592 if (i2c_transfer(client
->adapter
, &msg
, 1) != 1)
594 GTP_ERROR("I2C write 0x%X%X length=%d failed", buffer
[0], buffer
[1], len
);
602 s32
gtp_i2c_write(struct i2c_client
*client
, u8
*buf
, s32 len
)
605 u16 addr
= (buf
[0] << 8) + buf
[1];
607 ret
= i2c_write_bytes(client
, addr
, &buf
[2], len
- 2);
615 gtp_reset_guitar(client
, 20);
622 /*******************************************************
624 Send config Function.
630 Executive outcomes.0--success,non-0--fail.
631 *******************************************************/
632 s32
gtp_send_cfg(struct i2c_client
*client
)
635 #if GTP_DRIVER_SEND_CFG
638 for (retry
= 0; retry
< 5; retry
++)
640 #ifdef GTP_CHARGER_DETECT
642 if (gtp_charger_mode
== 1)
644 GTP_DEBUG("Write charger config");
645 ret
= gtp_i2c_write(client
, config_charger
, GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
);
649 GTP_DEBUG("Write normal config");
650 ret
= gtp_i2c_write(client
, config
, GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
);
654 ret
= gtp_i2c_write(client
, config
, GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
);
669 /*******************************************************
671 Read goodix touchscreen version function.
674 client: i2c client struct.
675 version:address to store version info
678 Executive outcomes.0---succeed.
679 *******************************************************/
680 s32
gtp_read_version(struct i2c_client
*client
, u16
*version
)
684 u8 buf
[8] = {GTP_REG_VERSION
>> 8, GTP_REG_VERSION
& 0xff};
688 ret
= gtp_i2c_read(client
, buf
, sizeof(buf
));
692 GTP_ERROR("GTP read version failed");
698 *version
= (buf
[7] << 8) | buf
[6];
701 tpd_info
.vid
= *version
;
705 for (i
= 0; i
< 3; i
++)
707 if (buf
[i
+ 2] < 0x30)break;
709 tpd_info
.pid
|= ((buf
[i
+ 2] - 0x30) << ((2 - i
) * 4));
712 GTP_INFO("IC VERSION:%c%c%c_%02x%02x",
713 buf
[2], buf
[3], buf
[4], buf
[7], buf
[6]);
717 /*******************************************************
719 GTP initialize function.
722 client: i2c client private struct.
725 Executive outcomes.0---succeed.
726 *******************************************************/
727 static s32
gtp_init_panel(struct i2c_client
*client
)
731 #if GTP_DRIVER_SEND_CFG
736 u8 cfg_info_group1
[] = CTP_CFG_GROUP1
;
737 u8 cfg_info_group2
[] = CTP_CFG_GROUP2
;
738 u8 cfg_info_group3
[] = CTP_CFG_GROUP3
;
739 u8
*send_cfg_buf
[3] = {cfg_info_group1
, cfg_info_group2
, cfg_info_group3
};
740 #ifdef GTP_CHARGER_DETECT
741 u8 cfg_info_group1_charger
[] = CTP_CFG_GROUP1_CHARGER
;
742 u8 cfg_info_group2_charger
[] = CTP_CFG_GROUP2_CHARGER
;
743 u8 cfg_info_group3_charger
[] = CTP_CFG_GROUP3_CHARGER
;
744 u8
*send_cfg_buf_charger
[3] = {cfg_info_group1_charger
, cfg_info_group2_charger
, cfg_info_group3_charger
};
746 u8 cfg_info_len
[3] = {sizeof(cfg_info_group1
) / sizeof(cfg_info_group1
[0]),
747 sizeof(cfg_info_group2
) / sizeof(cfg_info_group2
[0]),
748 sizeof(cfg_info_group3
) / sizeof(cfg_info_group3
[0])
751 for (i
= 0; i
< 3; i
++)
753 if (cfg_info_len
[i
] > cfg_len
)
755 cfg_len
= cfg_info_len
[i
];
759 GTP_DEBUG("len1=%d,len2=%d,len3=%d,get_len=%d", cfg_info_len
[0], cfg_info_len
[1], cfg_info_len
[2], cfg_len
);
761 if ((!cfg_info_len
[1]) && (!cfg_info_len
[2]))
763 rd_cfg_buf
[GTP_ADDR_LENGTH
] = 0;
767 rd_cfg_buf
[0] = GTP_REG_SENSOR_ID
>> 8;
768 rd_cfg_buf
[1] = GTP_REG_SENSOR_ID
& 0xff;
769 ret
= gtp_i2c_read(client
, rd_cfg_buf
, 3);
773 GTP_ERROR("Read SENSOR ID failed,default use group1 config!");
774 rd_cfg_buf
[GTP_ADDR_LENGTH
] = 0;
778 rd_cfg_buf
[GTP_ADDR_LENGTH
] &= 0x03;
781 GTP_INFO("SENSOR ID:%d", rd_cfg_buf
[GTP_ADDR_LENGTH
]);
782 memset(&config
[GTP_ADDR_LENGTH
], 0, GTP_CONFIG_MAX_LENGTH
);
783 memcpy(&config
[GTP_ADDR_LENGTH
], send_cfg_buf
[rd_cfg_buf
[GTP_ADDR_LENGTH
]], cfg_len
);
784 #ifdef GTP_CHARGER_DETECT
785 memset(&config_charger
[GTP_ADDR_LENGTH
], 0, GTP_CONFIG_MAX_LENGTH
);
786 memcpy(&config_charger
[GTP_ADDR_LENGTH
], send_cfg_buf_charger
[rd_cfg_buf
[GTP_ADDR_LENGTH
]], cfg_len
);
790 config
[RESOLUTION_LOC
] = (u8
)GTP_MAX_WIDTH
;
791 config
[RESOLUTION_LOC
+ 1] = (u8
)(GTP_MAX_WIDTH
>> 8);
792 config
[RESOLUTION_LOC
+ 2] = (u8
)GTP_MAX_HEIGHT
;
793 config
[RESOLUTION_LOC
+ 3] = (u8
)(GTP_MAX_HEIGHT
>> 8);
795 if (GTP_INT_TRIGGER
== 0) //RISING
797 config
[TRIGGER_LOC
] &= 0xfe;
799 else if (GTP_INT_TRIGGER
== 1) //FALLING
801 config
[TRIGGER_LOC
] |= 0x01;
804 #endif //endif GTP_CUSTOM_CFG
808 for (i
= GTP_ADDR_LENGTH
; i
< cfg_len
; i
++)
810 check_sum
+= config
[i
];
813 config
[cfg_len
] = (~check_sum
) + 1;
814 #ifdef GTP_CHARGER_DETECT
817 for (i
= GTP_ADDR_LENGTH
; i
< cfg_len
; i
++)
819 check_sum
+= config_charger
[i
];
822 config_charger
[cfg_len
] = (~check_sum
) + 1;
824 #else //else DRIVER NEED NOT SEND CONFIG
828 cfg_len
= GTP_CONFIG_MAX_LENGTH
;
831 ret
= gtp_i2c_read(client
, config
, cfg_len
+ GTP_ADDR_LENGTH
);
835 GTP_ERROR("GTP read resolution & max_touch_num failed, use default value!");
836 abs_x_max
= GTP_MAX_WIDTH
;
837 abs_y_max
= GTP_MAX_HEIGHT
;
838 int_type
= GTP_INT_TRIGGER
;
842 #endif //endif GTP_DRIVER_SEND_CFG
844 abs_x_max
= (config
[RESOLUTION_LOC
+ 1] << 8) + config
[RESOLUTION_LOC
];
845 abs_y_max
= (config
[RESOLUTION_LOC
+ 3] << 8) + config
[RESOLUTION_LOC
+ 2];
846 int_type
= (config
[TRIGGER_LOC
]) & 0x03;
848 if ((!abs_x_max
) || (!abs_y_max
))
850 GTP_ERROR("GTP resolution & max_touch_num invalid, use default value!");
851 abs_x_max
= GTP_MAX_WIDTH
;
852 abs_y_max
= GTP_MAX_HEIGHT
;
855 ret
= gtp_send_cfg(client
);
859 GTP_ERROR("Send config error.");
863 GTP_DEBUG("X_MAX = %d,Y_MAX = %d,TRIGGER = 0x%02x", abs_x_max
, abs_y_max
, int_type
);
870 static s8
gtp_i2c_test(struct i2c_client
*client
)
881 ret
= i2c_read_bytes(client
, GTP_REG_HW_INFO
, (u8
*)&hw_info
, sizeof(hw_info
));
883 if ((!ret
) && (hw_info
== 0x00900600)) //20121212
888 GTP_ERROR("GTP_REG_HW_INFO : %08X", hw_info
);
889 GTP_ERROR("GTP i2c test failed time %d.", retry
);
896 /*******************************************************
898 Set INT pin as input for FW sync.
901 If the INT is high, It means there is pull up resistor attached on the INT pin.
902 Pull low the INT pin manaully for FW sync.
903 *******************************************************/
906 GTP_DEBUG("There is pull up resisitor attached on the INT pin~!");
907 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
909 GTP_GPIO_AS_INT(GTP_INT_PORT
);
912 void gtp_reset_guitar(struct i2c_client
*client
, s32 ms
)
914 GTP_INFO("GTP RESET!");
915 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
917 GTP_GPIO_OUTPUT(GTP_INT_PORT
, client
->addr
== 0x14);
919 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 1);
926 static int tpd_power_on(struct i2c_client
*client
)
932 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
933 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
935 //power on, need confirm with SA
936 #ifdef TPD_POWER_SOURCE_CUSTOM
937 hwPowerOn(TPD_POWER_SOURCE_CUSTOM
, VOL_3000
, "TP");
939 hwPowerOn(MT65XX_POWER_LDO_VGP2
, VOL_3300
, "TP");
941 #ifdef TPD_POWER_SOURCE_1800
942 hwPowerOn(TPD_POWER_SOURCE_1800
, VOL_1800
, "TP");
945 gtp_reset_guitar(client
, 20);
946 GTP_ERROR("GTP_INT_PORT:0x%x, GTP_RST_PORT:0x%x", GTP_INT_PORT
, GTP_RST_PORT
);
947 ret
= gtp_i2c_test(client
);
951 GTP_ERROR("I2C communication ERROR!");
953 if (reset_count
< TPD_MAX_RESET_COUNT
)
965 ret
= gup_init_fw_proc(client
);
969 GTP_ERROR("Create fw download thread error.");
977 #ifdef MTK_CTP_RESET_CONFIG
978 static int tpd_clear_config(void *unused
)
980 int ret
=0, check_sum
=0;
981 u8 temp_data
= 0, i
=0;
982 u8 config_1st
[GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
]
983 = {GTP_REG_CONFIG_DATA
>> 8, GTP_REG_CONFIG_DATA
& 0xff};
985 GTP_INFO("Clear Config Begin......");
986 msleep(10000); //wait main thread to be completed
988 ret
= i2c_read_bytes(i2c_client_point
, GTP_REG_CONFIG_DATA
, &temp_data
, 1);
991 GTP_ERROR("GTP read config failed!");
995 GTP_INFO("IC config version: 0x%x; Driver config version: 0x%x",temp_data
, config
[GTP_ADDR_LENGTH
]);
996 if((temp_data
<(u8
)0x5A)&&(temp_data
>config
[GTP_ADDR_LENGTH
]))
998 memset(&config_1st
[GTP_ADDR_LENGTH
], 0, GTP_CONFIG_MAX_LENGTH
);
999 memcpy(&config_1st
[GTP_ADDR_LENGTH
], &config
[GTP_ADDR_LENGTH
], cfg_len
);
1000 config_1st
[GTP_ADDR_LENGTH
] = 0;
1003 for (i
= GTP_ADDR_LENGTH
; i
< cfg_len
; i
++)
1005 check_sum
+= config_1st
[i
];
1008 config_1st
[cfg_len
] = (~check_sum
) + 1;
1009 ret
= gtp_i2c_write(i2c_client_point
, config_1st
, GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
);
1012 GTP_ERROR("GTP write 00 config failed!");
1015 GTP_INFO("Force clear cfg done");
1019 GTP_INFO("No need clear cfg");
1025 static const struct file_operations gt_upgrade_proc_fops
= {
1026 .write
= gt91xx_config_write_proc
,
1027 .read
= gt91xx_config_read_proc
1031 static s32
tpd_i2c_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
1036 struct task_struct
*thread
= NULL
;
1037 #if 0 //GTP_HAVE_TOUCH_KEY
1040 #ifdef TPD_PROXIMITY
1041 struct hwmsen_object obj_ps
;
1044 i2c_client_point
= client
;
1045 ret
= tpd_power_on(client
);
1049 GTP_ERROR("I2C communication ERROR!");
1053 #ifdef MTK_CTP_RESET_CONFIG
1054 thread
= kthread_run(tpd_clear_config
, 0, "mtk-tpd-clear-config");
1057 err
= PTR_ERR(thread
);
1058 GTP_INFO(TPD_DEVICE
" failed to create kernel thread for clearing config: %d", err
);
1064 ret
= gup_init_update_proc(client
);
1068 GTP_ERROR("Create update thread error.");
1076 #ifdef VELOCITY_CUSTOM
1077 tpd_v_magnify_x
= TPD_VELOCITY_CUSTOM_X
;
1078 tpd_v_magnify_y
= TPD_VELOCITY_CUSTOM_Y
;
1082 ret
= gtp_read_version(client
, &version_info
);
1086 GTP_ERROR("Read version failed.");
1090 ret
= gtp_init_panel(client
);
1094 GTP_ERROR("GTP init panel failed.");
1097 GTP_DEBUG("gtp_init_panel success");
1098 // Create proc file system
1099 gt91xx_config_proc
= proc_create(GT91XX_CONFIG_PROC_FILE
, 0660, NULL
, >_upgrade_proc_fops
);
1101 if (gt91xx_config_proc
== NULL
)
1103 GTP_ERROR("create_proc_entry %s failed", GT91XX_CONFIG_PROC_FILE
);
1107 #if GTP_CREATE_WR_NODE
1108 init_wr_node(client
);
1111 thread
= kthread_run(touch_event_handler
, 0, TPD_DEVICE
);
1115 err
= PTR_ERR(thread
);
1116 GTP_ERROR(TPD_DEVICE
" failed to create kernel thread: %d", err
);
1120 #if 0//GTP_HAVE_TOUCH_KEY
1122 for (idx
= 0; idx
< TPD_KEY_COUNT
; idx
++)
1124 input_set_capability(tpd
->dev
, EV_KEY
, touch_key_array
[idx
]);
1129 if (!int_type
) //EINTF_TRIGGER
1131 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM
, EINTF_TRIGGER_RISING
, tpd_eint_interrupt_handler
, 0);
1135 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM
, EINTF_TRIGGER_FALLING
, tpd_eint_interrupt_handler
, 0);// disable auto-unmask
1138 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
1140 #ifdef TPD_PROXIMITY
1141 //obj_ps.self = cm3623_obj;
1142 obj_ps
.polling
= 0; //0--interrupt mode;1--polling mode;
1143 obj_ps
.sensor_operate
= tpd_ps_operate
;
1145 if ((err
= hwmsen_attach(ID_PROXIMITY
, &obj_ps
)))
1147 GTP_ERROR("hwmsen attach fail, return:%d.", err
);
1153 INIT_DELAYED_WORK(>p_esd_check_work
, gtp_esd_check_func
);
1154 gtp_esd_check_workqueue
= create_workqueue("gtp_esd_check");
1155 queue_delayed_work(gtp_esd_check_workqueue
, >p_esd_check_work
, TPD_ESD_CHECK_CIRCLE
);
1158 #ifdef GTP_CHARGER_DETECT
1159 INIT_DELAYED_WORK(>p_charger_check_work
, gtp_charger_check_func
);
1160 gtp_charger_check_workqueue
= create_workqueue("gtp_charger_check");
1161 queue_delayed_work(gtp_charger_check_workqueue
, >p_charger_check_work
, TPD_CHARGER_CHECK_CIRCLE
);
1163 tpd_load_status
= 1;
1165 GTP_INFO("%s, success run Done", __FUNCTION__
);
1171 static void tpd_eint_interrupt_handler(void)
1173 TPD_DEBUG_PRINT_INT
;
1175 wake_up_interruptible(&waiter
);
1177 static int tpd_i2c_remove(struct i2c_client
*client
)
1179 #if GTP_CREATE_WR_NODE
1184 destroy_workqueue(gtp_esd_check_workqueue
);
1188 destroy_workqueue(gtp_charger_check_workqueue
);
1192 #ifdef GTP_CHARGER_DETECT
1193 static void gtp_charger_check_func(struct work_struct
*work
)
1195 int cur_charger_state
;
1196 cur_charger_state
= upmu_get_pchr_chrdet();
1198 GTP_DEBUG("Charger mode = %d", cur_charger_state
);
1200 if (gtp_charger_mode
!= cur_charger_state
)
1202 GTP_DEBUG("Charger state change detected~!");
1203 GTP_DEBUG("Charger mode = %d", cur_charger_state
);
1204 gtp_charger_mode
= cur_charger_state
;
1205 gtp_send_cfg(i2c_client_point
);
1210 queue_delayed_work(gtp_charger_check_workqueue
, >p_charger_check_work
, TPD_CHARGER_CHECK_CIRCLE
);
1218 static void force_reset_guitar(void)
1223 GTP_INFO("force_reset_guitar");
1226 #ifdef TPD_POWER_SOURCE_CUSTOM
1227 hwPowerDown(TPD_POWER_SOURCE_CUSTOM
, "TP");
1229 hwPowerDown(MT65XX_POWER_LDO_VGP2
, "TP");
1231 #ifdef TPD_POWER_SOURCE_1800
1232 hwPowerDown(TPD_POWER_SOURCE_1800
, "TP");
1236 #ifdef TPD_POWER_SOURCE_CUSTOM
1237 hwPowerOn(TPD_POWER_SOURCE_CUSTOM
, VOL_3000
, "TP");
1239 hwPowerOn(MT65XX_POWER_LDO_VGP2
, VOL_3300
, "TP");
1241 #ifdef TPD_POWER_SOURCE_1800
1242 hwPowerOn(TPD_POWER_SOURCE_1800
, VOL_1800
, "TP");
1245 for (i
= 0; i
< 5; i
++)
1248 gtp_reset_guitar(i2c_client_point
, 20);
1251 ret
= gtp_send_cfg(i2c_client_point
);
1263 static void gtp_esd_check_func(struct work_struct
*work
)
1267 u8 test
[3] = {GTP_REG_CONFIG_DATA
>> 8, GTP_REG_CONFIG_DATA
& 0xff};
1274 for (i
= 0; i
< 3; i
++)
1276 ret
= gtp_i2c_read(i2c_client_point
, test
, 3);
1286 force_reset_guitar();
1291 queue_delayed_work(gtp_esd_check_workqueue
, >p_esd_check_work
, TPD_ESD_CHECK_CIRCLE
);
1297 static int tpd_history_x
=0, tpd_history_y
=0;
1298 static void tpd_down(s32 x
, s32 y
, s32 size
, s32 id
)
1300 if ((!size
) && (!id
))
1302 input_report_abs(tpd
->dev
, ABS_MT_PRESSURE
, 100);
1303 input_report_abs(tpd
->dev
, ABS_MT_TOUCH_MAJOR
, 100);
1307 input_report_abs(tpd
->dev
, ABS_MT_PRESSURE
, size
);
1308 input_report_abs(tpd
->dev
, ABS_MT_TOUCH_MAJOR
, size
);
1309 /* track id Start 0 */
1310 input_report_abs(tpd
->dev
, ABS_MT_TRACKING_ID
, id
);
1313 input_report_key(tpd
->dev
, BTN_TOUCH
, 1);
1314 input_report_abs(tpd
->dev
, ABS_MT_POSITION_X
, x
);
1315 input_report_abs(tpd
->dev
, ABS_MT_POSITION_Y
, y
);
1316 input_mt_sync(tpd
->dev
);
1318 TPD_EM_PRINT(x
, y
, x
, y
, id
, 1);
1322 MMProfileLogEx(MMP_TouchPanelEvent
, MMProfileFlagPulse
, 1, x
+y
);
1323 #ifdef TPD_HAVE_BUTTON
1325 if (FACTORY_BOOT
== get_boot_mode() || RECOVERY_BOOT
== get_boot_mode())
1327 tpd_button(x
, y
, 1);
1333 static void tpd_up(s32 x
, s32 y
, s32 id
)
1335 //input_report_abs(tpd->dev, ABS_MT_PRESSURE, 0);
1336 input_report_key(tpd
->dev
, BTN_TOUCH
, 0);
1337 //input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 0);
1338 input_mt_sync(tpd
->dev
);
1340 TPD_EM_PRINT(tpd_history_x
, tpd_history_y
, tpd_history_x
, tpd_history_y
, id
, 0);
1343 MMProfileLogEx(MMP_TouchPanelEvent
, MMProfileFlagPulse
, 0, x
+y
);
1345 #ifdef TPD_HAVE_BUTTON
1347 if (FACTORY_BOOT
== get_boot_mode() || RECOVERY_BOOT
== get_boot_mode())
1349 tpd_button(x
, y
, 0);
1355 /*Coordination mapping*/
1356 static void tpd_calibrate_driver(int *x
, int *y
)
1360 GTP_DEBUG("Call tpd_calibrate of this driver ..\n");
1362 tx
= ( (tpd_def_calmat
[0] * (*x
)) + (tpd_def_calmat
[1] * (*y
)) + (tpd_def_calmat
[2]) ) >> 12;
1363 *y
= ( (tpd_def_calmat
[3] * (*x
)) + (tpd_def_calmat
[4] * (*y
)) + (tpd_def_calmat
[5]) ) >> 12;
1367 static int touch_event_handler(void *unused
)
1369 struct sched_param param
= { .sched_priority
= RTPM_PRIO_TPD
};
1370 u8 end_cmd
[3] = {GTP_READ_COOR_ADDR
>> 8, GTP_READ_COOR_ADDR
& 0xFF, 0};
1371 u8 point_data
[2 + 1 + 8 * GTP_MAX_TOUCH
+ 1] = {GTP_READ_COOR_ADDR
>> 8, GTP_READ_COOR_ADDR
& 0xFF};
1374 static u8 pre_touch
= 0;
1375 static u8 pre_key
= 0;
1377 u8
*coor_data
= NULL
;
1384 #ifdef TPD_PROXIMITY
1386 hwm_sensor_data sensor_data
;
1387 u8 proximity_status
;
1393 sched_setscheduler(current
, SCHED_RR
, ¶m
);
1397 set_current_state(TASK_INTERRUPTIBLE
);
1400 wait_event_interruptible(waiter
, tpd_flag
!= 0);
1405 msleep(tpd_polling_time
);
1407 set_current_state(TASK_RUNNING
);
1409 mutex_lock(&i2c_access
);
1413 mutex_unlock(&i2c_access
);
1414 GTP_DEBUG("return for interrupt after suspend... ");
1418 ret
= gtp_i2c_read(i2c_client_point
, point_data
, 12);
1422 GTP_ERROR("I2C transfer error. errno:%d ", ret
);
1423 goto exit_work_func
;
1426 finger
= point_data
[GTP_ADDR_LENGTH
];
1428 if ((finger
& 0x80) == 0)
1430 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
1431 mutex_unlock(&i2c_access
);
1432 GTP_ERROR("buffer not ready");
1436 #ifdef TPD_PROXIMITY
1438 if (tpd_proximity_flag
== 1)
1440 proximity_status
= point_data
[GTP_ADDR_LENGTH
];
1441 GTP_DEBUG("REG INDEX[0x814E]:0x%02X", proximity_status
);
1443 if (proximity_status
& 0x60) //proximity or large touch detect,enable hwm_sensor.
1445 tpd_proximity_detect
= 0;
1446 //sensor_data.values[0] = 0;
1450 tpd_proximity_detect
= 1;
1451 //sensor_data.values[0] = 1;
1455 GTP_DEBUG(" ps change");
1456 GTP_DEBUG("PROXIMITY STATUS:0x%02X", tpd_proximity_detect
);
1457 //map and store data to hwm_sensor_data
1458 sensor_data
.values
[0] = tpd_get_ps_value();
1459 sensor_data
.value_divide
= 1;
1460 sensor_data
.status
= SENSOR_STATUS_ACCURACY_MEDIUM
;
1461 //report to the up-layer
1462 ret
= hwmsen_get_interrupt_data(ID_PROXIMITY
, &sensor_data
);
1466 GTP_ERROR("Call hwmsen_get_interrupt_data fail = %d", err
);
1472 touch_num
= finger
& 0x0f;
1474 if (touch_num
> GTP_MAX_TOUCH
)
1476 GTP_ERROR("Bad number of fingers!");
1477 goto exit_work_func
;
1482 u8 buf
[8 * GTP_MAX_TOUCH
] = {(GTP_READ_COOR_ADDR
+ 10) >> 8, (GTP_READ_COOR_ADDR
+ 10) & 0xff};
1484 ret
= gtp_i2c_read(i2c_client_point
, buf
, 2 + 8 * (touch_num
- 1));
1485 memcpy(&point_data
[12], &buf
[2], 8 * (touch_num
- 1));
1487 #if GTP_HAVE_TOUCH_KEY
1488 key_value
= point_data
[3 + 8 * touch_num
];
1490 if (key_value
|| pre_key
)
1492 for (i
= 0; i
< TPD_KEY_COUNT
; i
++)
1494 //input_report_key(tpd->dev, touch_key_array[i], key_value & (0x01 << i));
1495 if( key_value
&(0x01<<i
) ) //key=1 menu ;key=2 home; key =4 back;
1497 input_x
=touch_key_point_maping_array
[i
].point_x
;
1498 input_y
= touch_key_point_maping_array
[i
].point_y
;
1499 GTP_DEBUG("button =%d %d",input_x
,input_y
);
1501 tpd_down( input_x
, input_y
, 0, 0);
1505 if((pre_key
!=0)&&(key_value
==0))
1515 pre_key
= key_value
;
1517 GTP_DEBUG("pre_touch:%02x, finger:%02x.", pre_touch
, finger
);
1521 for (i
= 0; i
< touch_num
; i
++)
1523 coor_data
= &point_data
[i
* 8 + 3];
1525 id
= coor_data
[0]&0x0F;
1526 input_x
= coor_data
[1] | coor_data
[2] << 8;
1527 input_y
= coor_data
[3] | coor_data
[4] << 8;
1528 input_w
= coor_data
[5] | coor_data
[6] << 8;
1530 GTP_DEBUG("Original touch point : [X:%04d, Y:%04d]", input_x
, input_y
);
1532 input_x
= TPD_WARP_X(abs_x_max
, input_x
);
1533 input_y
= TPD_WARP_Y(abs_y_max
, input_y
);
1534 tpd_calibrate_driver(&input_x
, &input_y
);
1536 GTP_DEBUG("Touch point after calibration: [X:%04d, Y:%04d]", input_x
, input_y
);
1544 tpd_down(input_x
, input_y
, input_w
, id
);
1549 GTP_DEBUG("Touch Release!");
1554 GTP_DEBUG("Additional Eint!");
1556 pre_touch
= touch_num
;
1557 //input_report_key(tpd->dev, BTN_TOUCH, (touch_num || key_value));
1559 if (tpd
!= NULL
&& tpd
->dev
!= NULL
)
1561 input_sync(tpd
->dev
);
1566 if (!gtp_rawdiff_mode
)
1568 ret
= gtp_i2c_write(i2c_client_point
, end_cmd
, 3);
1572 GTP_INFO("I2C write end_cmd error!");
1575 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
1576 mutex_unlock(&i2c_access
);
1579 while (!kthread_should_stop());
1584 static int tpd_local_init(void)
1587 if (i2c_add_driver(&tpd_i2c_driver
) != 0)
1589 GTP_INFO("unable to add i2c driver.");
1593 if (tpd_load_status
== 0) //if(tpd_load_status == 0) // disable auto load touch driver for linux3.0 porting
1595 GTP_INFO("add error touch panel driver.");
1596 i2c_del_driver(&tpd_i2c_driver
);
1599 input_set_abs_params(tpd
->dev
, ABS_MT_TRACKING_ID
, 0, (GTP_MAX_TOUCH
-1), 0, 0);
1600 #ifdef TPD_HAVE_BUTTON
1601 tpd_button_setting(TPD_KEY_COUNT
, tpd_keys_local
, tpd_keys_dim_local
);// initialize tpd button data
1604 #if (defined(TPD_WARP_START) && defined(TPD_WARP_END))
1606 memcpy(tpd_wb_start
, tpd_wb_start_local
, TPD_WARP_CNT
* 4);
1607 memcpy(tpd_wb_end
, tpd_wb_start_local
, TPD_WARP_CNT
* 4);
1610 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
1611 //memcpy(tpd_calmat, tpd_def_calmat_local, 8 * 4);
1612 //memcpy(tpd_def_calmat, tpd_def_calmat_local, 8 * 4);
1613 if (FACTORY_BOOT
== get_boot_mode())
1615 TPD_DEBUG("Factory mode is detected! \n");
1616 memcpy(tpd_calmat
, tpd_def_calmat_local_factory
, 8 * 4);
1617 memcpy(tpd_def_calmat
, tpd_def_calmat_local_factory
, 8 * 4);
1621 TPD_DEBUG("Normal mode is detected! \n");
1622 memcpy(tpd_calmat
, tpd_def_calmat_local_normal
, 8 * 4);
1623 memcpy(tpd_def_calmat
, tpd_def_calmat_local_normal
, 8 * 4);
1627 // set vendor string
1628 tpd
->dev
->id
.vendor
= 0x00;
1629 tpd
->dev
->id
.product
= tpd_info
.pid
;
1630 tpd
->dev
->id
.version
= tpd_info
.vid
;
1632 GTP_INFO("end %s, %d", __FUNCTION__
, __LINE__
);
1639 /*******************************************************
1641 Eter sleep function.
1647 Executive outcomes.0--success,non-0--fail.
1648 *******************************************************/
1649 static s8
gtp_enter_sleep(struct i2c_client
*client
)
1652 #if !GTP_POWER_CTRL_SLEEP
1654 u8 i2c_control_buf
[3] = {(u8
)(GTP_REG_SLEEP
>> 8), (u8
)GTP_REG_SLEEP
, 5};
1656 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
1661 ret
= gtp_i2c_write(client
, i2c_control_buf
, 3);
1665 GTP_INFO("GTP enter sleep!");
1674 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
1677 #ifdef TPD_POWER_SOURCE_CUSTOM
1678 hwPowerDown(TPD_POWER_SOURCE_CUSTOM
, "TP");
1680 hwPowerDown(MT65XX_POWER_LDO_VGP2
, "TP");
1682 #ifdef TPD_POWER_SOURCE_1800
1683 hwPowerDown(TPD_POWER_SOURCE_1800
, "TP");
1686 GTP_INFO("GTP enter sleep!");
1690 GTP_ERROR("GTP send sleep cmd failed.");
1694 /*******************************************************
1696 Wakeup from sleep mode Function.
1702 Executive outcomes.0--success,non-0--fail.
1703 *******************************************************/
1704 static s8
gtp_wakeup_sleep(struct i2c_client
*client
)
1710 GTP_INFO("GTP wakeup begin.");
1711 #if GTP_POWER_CTRL_SLEEP
1715 ret
= tpd_power_on(client
);
1719 GTP_ERROR("I2C Power on ERROR!");
1722 ret
= gtp_send_cfg(client
);
1726 GTP_DEBUG("Wakeup sleep send config success.");
1733 while (retry
++ < 10)
1735 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 1);
1737 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
1739 ret
= gtp_i2c_test(client
);
1747 gtp_reset_guitar(client
, 20);
1752 GTP_ERROR("GTP wakeup sleep failed.");
1755 /* Function to manage low power suspend */
1756 static void tpd_suspend(struct early_suspend
*h
)
1759 mutex_lock(&i2c_access
);
1760 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
1762 mutex_unlock(&i2c_access
);
1764 ret
= gtp_enter_sleep(i2c_client_point
);
1767 GTP_ERROR("GTP early suspend failed.");
1771 cancel_delayed_work_sync(>p_esd_check_work
);
1774 #ifdef GTP_CHARGER_DETECT
1775 cancel_delayed_work_sync(>p_charger_check_work
);
1777 #ifdef TPD_PROXIMITY
1779 if (tpd_proximity_flag
== 1)
1787 /* Function to manage power-on resume */
1788 static void tpd_resume(struct early_suspend
*h
)
1792 ret
= gtp_wakeup_sleep(i2c_client_point
);
1796 GTP_ERROR("GTP later resume failed.");
1799 GTP_INFO("GTP wakeup sleep.");
1801 mutex_lock(&i2c_access
);
1803 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
1804 mutex_unlock(&i2c_access
);
1806 #ifdef TPD_PROXIMITY
1807 if (tpd_proximity_flag
== 1)
1814 queue_delayed_work(gtp_esd_check_workqueue
, >p_esd_check_work
, TPD_ESD_CHECK_CIRCLE
);
1817 #ifdef GTP_CHARGER_DETECT
1818 queue_delayed_work(gtp_charger_check_workqueue
, >p_charger_check_work
, TPD_CHARGER_CHECK_CIRCLE
);
1823 static void tpd_off(void)
1826 #ifdef TPD_POWER_SOURCE_CUSTOM
1827 hwPowerDown(TPD_POWER_SOURCE_CUSTOM
, "TP");
1829 hwPowerDown(MT65XX_POWER_LDO_VGP2
, "TP");
1831 #ifdef TPD_POWER_SOURCE_1800
1832 hwPowerDown(TPD_POWER_SOURCE_1800
, "TP");
1834 GTP_INFO("GTP enter sleep!");
1837 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
1840 static void tpd_on(void)
1842 s32 ret
= -1, retry
= 0;
1846 ret
= tpd_power_on(i2c_client_point
);
1850 GTP_ERROR("I2C Power on ERROR!");
1853 ret
= gtp_send_cfg(i2c_client_point
);
1857 GTP_DEBUG("Wakeup sleep send config success.");
1862 GTP_ERROR("GTP later resume failed.");
1865 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
1868 static struct tpd_driver_t tpd_device_driver
=
1870 .tpd_device_name
= "gt9xx",
1871 .tpd_local_init
= tpd_local_init
,
1872 .suspend
= tpd_suspend
,
1873 .resume
= tpd_resume
,
1874 #ifdef TPD_HAVE_BUTTON
1875 .tpd_have_button
= 1,
1877 .tpd_have_button
= 0,
1880 .attr
= gt9xx_attrs
,
1881 .num
= ARRAY_SIZE(gt9xx_attrs
),
1885 /* called when loaded into kernel */
1886 static int __init
tpd_driver_init(void)
1888 GTP_INFO("MediaTek gt91xx touch panel driver init");
1889 #if defined(TPD_I2C_NUMBER)
1890 i2c_register_board_info(TPD_I2C_NUMBER
, &i2c_tpd
, 1);
1892 i2c_register_board_info(0, &i2c_tpd
, 1);
1894 if (tpd_driver_add(&tpd_device_driver
) < 0)
1895 GTP_INFO("add generic driver failed");
1900 /* should never be called */
1901 static void __exit
tpd_driver_exit(void)
1903 GTP_INFO("MediaTek gt91xx touch panel driver exit");
1904 //input_unregister_device(tpd->dev);
1905 tpd_driver_remove(&tpd_device_driver
);
1908 module_init(tpd_driver_init
);
1909 module_exit(tpd_driver_exit
);