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 #if GTP_SUPPORT_I2C_DMA
14 #include <linux/dma-mapping.h>
16 #include <linux/proc_fs.h> /*proc*/
18 extern struct tpd_device
*tpd
;
19 #ifdef VELOCITY_CUSTOM
20 extern int tpd_v_magnify_x
;
21 extern int tpd_v_magnify_y
;
23 static int tpd_flag
= 0;
25 static int tpd_eint_mode
=1;
26 static struct task_struct
*thread
= NULL
;
27 static int tpd_polling_time
=50;
28 extern u8 load_fw_process
;
30 static DECLARE_WAIT_QUEUE_HEAD(waiter
);
31 DEFINE_MUTEX(i2c_access
);
33 #ifdef TPD_HAVE_BUTTON
34 static int tpd_keys_local
[TPD_KEY_COUNT
] = TPD_KEYS
;
35 static int tpd_keys_dim_local
[TPD_KEY_COUNT
][4] = TPD_KEYS_DIM
;
38 #if GTP_HAVE_TOUCH_KEY
39 const u16 touch_key_array
[] = TPD_KEYS
;
40 #define GTP_MAX_KEY_NUM ( sizeof( touch_key_array )/sizeof( touch_key_array[0] ) )
41 struct touch_vitual_key_map_t
46 static struct touch_vitual_key_map_t touch_key_point_maping_array
[]=GTP_KEY_MAP_ARRAY
;
56 static DOZE_T doze_status
= DOZE_DISABLED
;
57 static s8
gtp_enter_doze(struct i2c_client
*client
);
60 #if GTP_CHARGER_SWITCH
61 extern kal_bool
upmu_is_chr_det(void);
62 static void gtp_charger_switch(s32 dir_update
);
65 #if (defined(TPD_WARP_START) && defined(TPD_WARP_END))
66 static int tpd_wb_start_local
[TPD_WARP_CNT
] = TPD_WARP_START
;
67 static int tpd_wb_end_local
[TPD_WARP_CNT
] = TPD_WARP_END
;
70 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
71 //static int tpd_calmat_local[8] = TPD_CALIBRATION_MATRIX;
72 //static int tpd_def_calmat_local[8] = TPD_CALIBRATION_MATRIX;
73 static int tpd_def_calmat_local_normal
[8] = TPD_CALIBRATION_MATRIX_ROTATION_NORMAL
;
74 static int tpd_def_calmat_local_factory
[8] = TPD_CALIBRATION_MATRIX_ROTATION_FACTORY
;
77 #if GTP_SUPPORT_I2C_DMA
78 s32
i2c_dma_write(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, s32 len
);
79 s32
i2c_dma_read(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, s32 len
);
81 static u8
*gpDMABuf_va
= NULL
;
82 static u32 gpDMABuf_pa
= 0;
85 s32
gtp_send_cfg(struct i2c_client
*client
);
86 void gtp_reset_guitar(struct i2c_client
*client
, s32 ms
);
87 static void tpd_eint_interrupt_handler(void);
88 static int touch_event_handler(void *unused
);
89 static int tpd_i2c_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
);
90 static int tpd_i2c_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
91 static int tpd_i2c_remove(struct i2c_client
*client
);
92 s32
gtp_i2c_read_dbl_check(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
);
93 extern void mt_eint_unmask(unsigned int line
);
94 extern void mt_eint_mask(unsigned int line
);
95 static void tpd_on(void);
96 static void tpd_off(void);
98 #ifdef GTP_CHARGER_DETECT
99 extern bool upmu_get_pchr_chrdet(void);
100 #define TPD_CHARGER_CHECK_CIRCLE 50
101 static struct delayed_work gtp_charger_check_work
;
102 static struct workqueue_struct
*gtp_charger_check_workqueue
= NULL
;
103 static void gtp_charger_check_func(struct work_struct
*);
104 static u8 gtp_charger_mode
= 0;
108 #if GTP_CREATE_WR_NODE
109 extern s32
init_wr_node(struct i2c_client
*);
110 extern void uninit_wr_node(void);
113 #if (GTP_ESD_PROTECT || GTP_COMPATIBLE_MODE)
114 void force_reset_guitar(void);
118 static int clk_tick_cnt
= 200;
119 static struct delayed_work gtp_esd_check_work
;
120 static struct workqueue_struct
*gtp_esd_check_workqueue
= NULL
;
121 static s32
gtp_init_ext_watchdog(struct i2c_client
*client
);
122 static void gtp_esd_check_func(struct work_struct
*);
123 void gtp_esd_switch(struct i2c_client
*client
, s32 on
);
129 u8 hotknot_paired_flag
= 0;
133 #define TPD_PROXIMITY_VALID_REG 0x814E
134 #define TPD_PROXIMITY_ENABLE_REG 0x8042
135 static u8 tpd_proximity_flag
= 0;
136 static u8 tpd_proximity_detect
= 1;//0-->close ; 1--> far away
139 #ifndef GTP_REG_REFRESH_RATE
140 #define GTP_REG_REFRESH_RATE 0x8056
143 struct i2c_client
*i2c_client_point
= NULL
;
144 static const struct i2c_device_id tpd_i2c_id
[] = {{"gt9xx", 0}, {}};
145 static unsigned short force
[] = {0, 0xBA, I2C_CLIENT_END
, I2C_CLIENT_END
};
146 static const unsigned short *const forces
[] = { force
, NULL
};
147 //static struct i2c_client_address_data addr_data = { .forces = forces,};
148 static struct i2c_board_info __initdata i2c_tpd
= { I2C_BOARD_INFO("gt9xx", (0xBA >> 1))};
149 static struct i2c_driver tpd_i2c_driver
=
151 .probe
= tpd_i2c_probe
,
152 .remove
= tpd_i2c_remove
,
153 .detect
= tpd_i2c_detect
,
154 .driver
.name
= "gt9xx",
155 .id_table
= tpd_i2c_id
,
156 .address_list
= (const unsigned short *) forces
,
160 static u8 config
[GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
]
161 = {GTP_REG_CONFIG_DATA
>> 8, GTP_REG_CONFIG_DATA
& 0xff};
162 #ifdef GTP_CHARGER_DETECT
163 static u8 config_charger
[GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
]
164 = {GTP_REG_CONFIG_DATA
>> 8, GTP_REG_CONFIG_DATA
& 0xff};
169 u16 pid
; //product id //
170 u16 vid
; //version id //
174 st_tpd_info tpd_info
;
178 u8 gtp_rawdiff_mode
= 0;
180 u8 grp_cfg_version
= 0;
182 u8 pnl_init_error
= 0;
183 static u8 chip_gt9xxs
= 0; // true if chip type is gt9xxs,like gt915s
185 #if GTP_COMPATIBLE_MODE
188 u8 gtp_ref_retries
= 0;
189 u8 gtp_clk_retries
= 0;
190 CHIP_TYPE_T gtp_chip_type
= CHIP_TYPE_GT9
;
192 u8 rqst_processing
= 0;
194 extern u8
gup_check_fs_mounted(char *path_name
);
195 extern u8
gup_clk_calibration(void);
196 extern s32
gup_load_main_system(char *filepath
);
197 extern s32
gup_fw_download_proc(void *dir
, u8 dwn_mode
);
198 void gtp_get_chip_type(struct i2c_client
*client
);
199 u8
gtp_fw_startup(struct i2c_client
*client
);
200 static u8
gtp_bak_ref_proc(struct i2c_client
*client
, u8 mode
);
201 static u8
gtp_main_clk_proc(struct i2c_client
*client
);
202 static void gtp_recovery_reset(struct i2c_client
*client
);
205 #if (GTP_ESD_PROTECT || GTP_COMPATIBLE_MODE)
209 /* proc file system */
210 s32
i2c_read_bytes(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
);
211 s32
i2c_write_bytes(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, int len
);
212 static struct proc_dir_entry
*gt91xx_config_proc
= NULL
;
214 #ifdef TPD_REFRESH_RATE
215 /*******************************************************
220 rate: refresh rate N (Duration=5+N ms, N=0~15)
223 Executive outcomes.0---succeed.
224 *******************************************************/
225 static u8
gtp_set_refresh_rate(u8 rate
)
227 u8 buf
[3] = {GTP_REG_REFRESH_RATE
>>8, GTP_REG_REFRESH_RATE
& 0xff, rate
};
231 GTP_ERROR("Refresh rate is over range (%d)", rate
);
235 GTP_INFO("Refresh rate change to %d", rate
);
236 return gtp_i2c_write(i2c_client_point
, buf
, sizeof(buf
));
239 /*******************************************************
244 Refresh rate or error code
245 *******************************************************/
246 static u8
gtp_get_refresh_rate(void)
250 u8 buf
[3] = {GTP_REG_REFRESH_RATE
>>8, GTP_REG_REFRESH_RATE
& 0xff};
251 ret
= gtp_i2c_read(i2c_client_point
, buf
, sizeof(buf
));
255 GTP_INFO("Refresh rate is %d", buf
[GTP_ADDR_LENGTH
]);
256 return buf
[GTP_ADDR_LENGTH
];
259 //=============================================================
260 static ssize_t
show_refresh_rate(struct device
*dev
,struct device_attribute
*attr
, char *buf
)
262 int ret
= gtp_get_refresh_rate();
266 return sprintf(buf
, "%d\n", ret
);
268 static ssize_t
store_refresh_rate(struct device
*dev
,struct device_attribute
*attr
, const char *buf
, size_t size
)
271 gtp_set_refresh_rate(simple_strtoul(buf
, NULL
, 16));
274 static DEVICE_ATTR(tpd_refresh_rate
, 0664, show_refresh_rate
, store_refresh_rate
);
276 static struct device_attribute
*gt9xx_attrs
[] =
278 &dev_attr_tpd_refresh_rate
,
281 //=============================================================
284 /* proc file system */
285 s32
i2c_read_bytes(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
);
286 s32
i2c_write_bytes(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, int len
);
288 static int tpd_i2c_detect(struct i2c_client
*client
, struct i2c_board_info
*info
)
290 strcpy(info
->type
, "mtk-tpd");
295 static s32
tpd_get_ps_value(void)
297 return tpd_proximity_detect
;
300 static s32
tpd_enable_ps(s32 enable
)
308 tpd_proximity_flag
= 1;
309 GTP_INFO("TPD proximity function to be on.");
314 tpd_proximity_flag
= 0;
315 GTP_INFO("TPD proximity function to be off.");
318 ret
= i2c_write_bytes(i2c_client_point
, TPD_PROXIMITY_ENABLE_REG
, &state
, 1);
322 GTP_ERROR("TPD %s proximity cmd failed.", state
? "enable" : "disable");
326 GTP_INFO("TPD proximity function %s success.", state
? "enable" : "disable");
330 s32
tpd_ps_operate(void *self
, u32 command
, void *buff_in
, s32 size_in
,
331 void *buff_out
, s32 size_out
, s32
*actualout
)
335 hwm_sensor_data
*sensor_data
;
340 if ((buff_in
== NULL
) || (size_in
< sizeof(int)))
342 GTP_ERROR("Set delay parameter error!");
350 if ((buff_in
== NULL
) || (size_in
< sizeof(int)))
352 GTP_ERROR("Enable sensor parameter error!");
357 value
= *(int *)buff_in
;
358 err
= tpd_enable_ps(value
);
363 case SENSOR_GET_DATA
:
364 if ((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
366 GTP_ERROR("Get sensor data parameter error!");
371 sensor_data
= (hwm_sensor_data
*)buff_out
;
372 sensor_data
->values
[0] = tpd_get_ps_value();
373 sensor_data
->value_divide
= 1;
374 sensor_data
->status
= SENSOR_STATUS_ACCURACY_MEDIUM
;
380 GTP_ERROR("proxmy sensor operate function no this parameter %d!\n", command
);
389 static int gt91xx_config_read_proc(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
393 char temp_data
[GTP_CONFIG_MAX_LENGTH
+ 2] = {0};
394 int i
, len
, err
= -1;
396 page
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
404 ptr
+= sprintf(ptr
, "==== GT9XX config init value====\n");
406 for (i
= 0 ; i
< GTP_CONFIG_MAX_LENGTH
; i
++)
408 ptr
+= sprintf(ptr
, "0x%02X ", config
[i
+ 2]);
411 ptr
+= sprintf(ptr
, "\n");
414 ptr
+= sprintf(ptr
, "\n");
416 ptr
+= sprintf(ptr
, "==== GT9XX config real value====\n");
417 i2c_read_bytes(i2c_client_point
, GTP_REG_CONFIG_DATA
, temp_data
, GTP_CONFIG_MAX_LENGTH
);
419 for (i
= 0 ; i
< GTP_CONFIG_MAX_LENGTH
; i
++)
421 ptr
+= sprintf(ptr
, "0x%02X ", temp_data
[i
]);
424 ptr
+= sprintf(ptr
, "\n");
426 /* Touch PID & VID */
427 ptr
+= sprintf(ptr
, "\n");
428 ptr
+= sprintf(ptr
, "==== GT9XX Version ID ====\n");
429 i2c_read_bytes(i2c_client_point
, GTP_REG_VERSION
, temp_data
, 6);
430 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]);
431 #if GTP_COMPATIBLE_MODE
432 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
434 ptr
+= sprintf(ptr
, "Driver VID: 0x%02X%02X\n", gtp_default_FW_fl
[12], gtp_default_FW_fl
[13]);
438 ptr
+= sprintf(ptr
, "Driver VID: 0x%02X%02X\n", gtp_default_FW
[12], gtp_default_FW
[13]);
441 ptr
+= sprintf(ptr
, "Driver VID: 0x%02X%02X\n", gtp_default_FW
[12], gtp_default_FW
[13]);
443 i2c_read_bytes(i2c_client_point
, 0x41E4, temp_data
, 1);
444 ptr
+= sprintf(ptr
, "Boot status 0x%X\n", temp_data
[0]);
446 /* Touch Status and Clock Gate */
447 ptr
+= sprintf(ptr
, "\n");
448 ptr
+= sprintf(ptr
, "==== Touch Status and Clock Gate ====\n");
449 ptr
+= sprintf(ptr
, "status: 1: on, 0 :off\n");
450 ptr
+= sprintf(ptr
, "status:%d\n", (tpd_halt
+1)&0x1);
459 err
= copy_to_user(buffer
,(char *)page
,len
);
469 //return (ptr - page);
472 static int gt91xx_config_write_proc(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
475 char temp
[25] = {0}; // for store special format cmd
476 char mode_str
[15] = {0};
480 GTP_DEBUG("write count %ld\n", (unsigned long)count
);
482 if (count
> GTP_CONFIG_MAX_LENGTH
)
484 GTP_ERROR("size not match [%d:%ld]", GTP_CONFIG_MAX_LENGTH
, (unsigned long)count
);
488 /**********************************************/
489 /* for store special format cmd */
490 if (copy_from_user(temp
, buffer
, sizeof(temp
)))
492 GTP_ERROR("copy from user fail 2");
495 sscanf(temp
, "%s %d", (char *)&mode_str
, &mode
);
497 /***********POLLING/EINT MODE switch****************/
498 if(strcmp(mode_str
, "polling") == 0)
500 if(mode
>=10&&mode
<=200)
502 GTP_INFO("Switch to polling mode, polling time is %d",mode
);
504 tpd_polling_time
=mode
;
506 wake_up_interruptible(&waiter
);
510 GTP_INFO("Wrong polling time, please set between 10~200ms");
514 if(strcmp(mode_str
, "eint") == 0)
516 GTP_INFO("Switch to eint mode");
520 /**********************************************/
521 if(strcmp(mode_str
, "switch") == 0)
523 if(mode
== 0)// turn off
525 else if(mode
== 1)//turn on
528 GTP_ERROR("error mode :%d", mode
);
532 if(strcmp(mode_str
, "clear_config") == 0)
534 GTP_INFO("Force clear config");
536 ret
= i2c_write_bytes(i2c_client_point
, GTP_REG_SLEEP
, buf
, 1);
540 if (copy_from_user(&config
[2], buffer
, count
))
542 GTP_ERROR("copy from user fail\n");
546 /***********clk operate reseved****************/
547 /**********************************************/
548 ret
= gtp_send_cfg(i2c_client_point
);
549 abs_x_max
= (config
[RESOLUTION_LOC
+ 1] << 8) + config
[RESOLUTION_LOC
];
550 abs_y_max
= (config
[RESOLUTION_LOC
+ 3] << 8) + config
[RESOLUTION_LOC
+ 2];
551 int_type
= (config
[TRIGGER_LOC
]) & 0x03;
555 GTP_ERROR("send config failed.");
561 #if GTP_SUPPORT_I2C_DMA
562 s32
i2c_dma_read(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, s32 len
)
568 struct i2c_msg msg
[2] =
571 .addr
= (client
->addr
& I2C_MASK_FLAG
),
575 .timing
= I2C_MASTER_CLOCK
578 .addr
= (client
->addr
& I2C_MASK_FLAG
),
579 .ext_flag
= (client
->ext_flag
| I2C_ENEXT_FLAG
| I2C_DMA_FLAG
),
581 .buf
= (u8
*)gpDMABuf_pa
,
583 .timing
= I2C_MASTER_CLOCK
587 buffer
[0] = (addr
>> 8) & 0xFF;
588 buffer
[1] = addr
& 0xFF;
593 //GTP_DEBUG("dma i2c read: 0x%04X, %d bytes(s)", addr, len);
594 for (retry
= 0; retry
< 5; ++retry
)
596 ret
= i2c_transfer(client
->adapter
, &msg
[0], 2);
601 memcpy(rxbuf
, gpDMABuf_va
, len
);
604 GTP_ERROR("Dma I2C Read Error: 0x%04X, %d byte(s), err-code: %d", addr
, len
, ret
);
609 s32
i2c_dma_write(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, s32 len
)
613 u8
*wr_buf
= gpDMABuf_va
;
617 .addr
= (client
->addr
& I2C_MASK_FLAG
),
618 .ext_flag
= (client
->ext_flag
| I2C_ENEXT_FLAG
| I2C_DMA_FLAG
),
620 .buf
= (u8
*)gpDMABuf_pa
,
622 .timing
= I2C_MASTER_CLOCK
625 wr_buf
[0] = (u8
)((addr
>> 8) & 0xFF);
626 wr_buf
[1] = (u8
)(addr
& 0xFF);
631 //GTP_DEBUG("dma i2c write: 0x%04X, %d bytes(s)", addr, len);
632 memcpy(wr_buf
+2, txbuf
, len
);
633 for (retry
= 0; retry
< 5; ++retry
)
635 ret
= i2c_transfer(client
->adapter
, &msg
, 1);
642 GTP_ERROR("Dma I2C Write Error: 0x%04X, %d byte(s), err-code: %d", addr
, len
, ret
);
646 s32
i2c_read_bytes_dma(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, s32 len
)
653 //GTP_DEBUG("Read bytes dma: 0x%04X, %d byte(s)", addr, len);
656 if (left
> GTP_DMA_MAX_TRANSACTION_LENGTH
)
658 read_len
= GTP_DMA_MAX_TRANSACTION_LENGTH
;
664 ret
= i2c_dma_read(client
, addr
, rd_buf
, read_len
);
667 GTP_ERROR("dma read failed");
678 s32
i2c_write_bytes_dma(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, s32 len
)
686 //GTP_DEBUG("Write bytes dma: 0x%04X, %d byte(s)", addr, len);
689 if (left
> GTP_DMA_MAX_I2C_TRANSFER_SIZE
)
691 write_len
= GTP_DMA_MAX_I2C_TRANSFER_SIZE
;
697 ret
= i2c_dma_write(client
, addr
, wr_buf
, write_len
);
701 GTP_ERROR("dma i2c write failed!");
714 int i2c_read_bytes_non_dma(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
)
716 u8 buffer
[GTP_ADDR_LENGTH
];
721 struct i2c_msg msg
[2] =
724 .addr
= ((client
->addr
&I2C_MASK_FLAG
) | (I2C_ENEXT_FLAG
)),
725 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
728 .len
= GTP_ADDR_LENGTH
,
729 .timing
= I2C_MASTER_CLOCK
732 .addr
= ((client
->addr
&I2C_MASK_FLAG
) | (I2C_ENEXT_FLAG
)),
733 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
735 .timing
= I2C_MASTER_CLOCK
742 GTP_DEBUG("i2c_read_bytes to device %02X address %04X len %d", client
->addr
, addr
, len
);
746 buffer
[0] = ((addr
+ offset
) >> 8) & 0xFF;
747 buffer
[1] = (addr
+ offset
) & 0xFF;
749 msg
[1].buf
= &rxbuf
[offset
];
751 if (left
> MAX_TRANSACTION_LENGTH
)
753 msg
[1].len
= MAX_TRANSACTION_LENGTH
;
754 left
-= MAX_TRANSACTION_LENGTH
;
755 offset
+= MAX_TRANSACTION_LENGTH
;
765 while (i2c_transfer(client
->adapter
, &msg
[0], 2) != 2)
771 GTP_ERROR("I2C read 0x%X length=%d failed\n", addr
+ offset
, len
);
781 int i2c_read_bytes(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
)
783 #if GTP_SUPPORT_I2C_DMA
784 return i2c_read_bytes_dma(client
, addr
, rxbuf
, len
);
786 return i2c_read_bytes_non_dma(client
, addr
, rxbuf
, len
);
790 s32
gtp_i2c_read(struct i2c_client
*client
, u8
*buf
, s32 len
)
793 u16 addr
= (buf
[0] << 8) + buf
[1];
795 ret
= i2c_read_bytes_non_dma(client
, addr
, &buf
[2], len
- 2);
804 if (DOZE_ENABLED
== doze_status
)
809 #if GTP_COMPATIBLE_MODE
810 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
812 gtp_recovery_reset(client
);
817 gtp_reset_guitar(client
, 20);
824 s32
gtp_i2c_read_dbl_check(struct i2c_client
*client
, u16 addr
, u8
*rxbuf
, int len
)
827 u8 confirm_buf
[16] = {0};
832 memset(buf
, 0xAA, 16);
833 buf
[0] = (u8
)(addr
>> 8);
834 buf
[1] = (u8
)(addr
& 0xFF);
835 gtp_i2c_read(client
, buf
, len
+ 2);
837 memset(confirm_buf
, 0xAB, 16);
838 confirm_buf
[0] = (u8
)(addr
>> 8);
839 confirm_buf
[1] = (u8
)(addr
& 0xFF);
840 gtp_i2c_read(client
, confirm_buf
, len
+ 2);
842 if (!memcmp(buf
, confirm_buf
, len
+2))
844 memcpy(rxbuf
, confirm_buf
+2, len
);
848 GTP_ERROR("i2c read 0x%04X, %d bytes, double check failed!", addr
, len
);
852 int i2c_write_bytes_non_dma(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, int len
)
854 u8 buffer
[MAX_TRANSACTION_LENGTH
];
861 .addr
= ((client
->addr
&I2C_MASK_FLAG
) | (I2C_ENEXT_FLAG
)),
862 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
865 .timing
= I2C_MASTER_CLOCK
,
872 GTP_DEBUG("i2c_write_bytes to device %02X address %04X len %d", client
->addr
, addr
, len
);
878 buffer
[0] = ((addr
+ offset
) >> 8) & 0xFF;
879 buffer
[1] = (addr
+ offset
) & 0xFF;
881 if (left
> MAX_I2C_TRANSFER_SIZE
)
883 memcpy(&buffer
[GTP_ADDR_LENGTH
], &txbuf
[offset
], MAX_I2C_TRANSFER_SIZE
);
884 msg
.len
= MAX_TRANSACTION_LENGTH
;
885 left
-= MAX_I2C_TRANSFER_SIZE
;
886 offset
+= MAX_I2C_TRANSFER_SIZE
;
890 memcpy(&buffer
[GTP_ADDR_LENGTH
], &txbuf
[offset
], left
);
891 msg
.len
= left
+ GTP_ADDR_LENGTH
;
895 //GTP_DEBUG("byte left %d offset %d\n", left, offset);
897 while (i2c_transfer(client
->adapter
, &msg
, 1) != 1)
903 GTP_ERROR("I2C write 0x%X%X length=%d failed\n", buffer
[0], buffer
[1], len
);
912 int i2c_write_bytes(struct i2c_client
*client
, u16 addr
, u8
*txbuf
, int len
)
914 #if GTP_SUPPORT_I2C_DMA
915 return i2c_write_bytes_dma(client
, addr
, txbuf
, len
);
917 return i2c_write_bytes_non_dma(client
, addr
, txbuf
, len
);
921 s32
gtp_i2c_write(struct i2c_client
*client
, u8
*buf
, s32 len
)
924 u16 addr
= (buf
[0] << 8) + buf
[1];
926 ret
= i2c_write_bytes_non_dma(client
, addr
, &buf
[2], len
- 2);
935 if (DOZE_ENABLED
== doze_status
)
940 #if GTP_COMPATIBLE_MODE
941 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
943 gtp_recovery_reset(client
);
948 gtp_reset_guitar(client
, 20);
956 /*******************************************************
958 Send config Function.
964 Executive outcomes.0--success,non-0--fail.
965 *******************************************************/
966 s32
gtp_send_cfg(struct i2c_client
*client
)
970 #if GTP_DRIVER_SEND_CFG
974 GTP_INFO("Ic fixed config, no config sent!");
977 else if (pnl_init_error
)
979 GTP_INFO("Error occurred in init_panel, no config sent!");
983 GTP_DEBUG("Driver Send Config");
984 for (retry
= 0; retry
< 5; retry
++)
986 ret
= gtp_i2c_write(client
, config
, GTP_CONFIG_MAX_LENGTH
+ GTP_ADDR_LENGTH
);
998 /*******************************************************
1000 Read goodix touchscreen version function.
1003 client: i2c client struct.
1004 version:address to store version info
1007 Executive outcomes.0---succeed.
1008 *******************************************************/
1009 s32
gtp_read_version(struct i2c_client
*client
, u16
*version
)
1013 u8 buf
[8] = {GTP_REG_VERSION
>> 8, GTP_REG_VERSION
& 0xff};
1017 ret
= gtp_i2c_read(client
, buf
, sizeof(buf
));
1021 GTP_ERROR("GTP read version failed");
1027 *version
= (buf
[7] << 8) | buf
[6];
1030 tpd_info
.vid
= *version
;
1031 tpd_info
.pid
= 0x00;
1033 for (i
= 0; i
< 4; i
++)
1035 if (buf
[i
+ 2] < 0x30)break;
1037 tpd_info
.pid
|= ((buf
[i
+ 2] - 0x30) << ((3 - i
) * 4));
1042 GTP_INFO("IC VERSION: %c%c%c_%02x%02x",
1043 buf
[2], buf
[3], buf
[4], buf
[7], buf
[6]);
1047 if (buf
[5] == 'S' || buf
[5] == 's')
1051 GTP_INFO("IC VERSION:%c%c%c%c_%02x%02x",
1052 buf
[2], buf
[3], buf
[4], buf
[5], buf
[7], buf
[6]);
1057 #if GTP_DRIVER_SEND_CFG
1058 /*******************************************************
1060 Get information from ic, such as resolution and
1063 client: i2c client private struct.
1066 FAIL: i2c failed, SUCCESS: i2c ok
1067 *******************************************************/
1068 static s32
gtp_get_info(struct i2c_client
*client
)
1070 u8 opr_buf
[6] = {0};
1073 opr_buf
[0] = (u8
)((GTP_REG_CONFIG_DATA
+1) >> 8);
1074 opr_buf
[1] = (u8
)((GTP_REG_CONFIG_DATA
+1) & 0xFF);
1076 ret
= gtp_i2c_read(client
, opr_buf
, 6);
1082 abs_x_max
= (opr_buf
[3] << 8) + opr_buf
[2];
1083 abs_y_max
= (opr_buf
[5] << 8) + opr_buf
[4];
1085 opr_buf
[0] = (u8
)((GTP_REG_CONFIG_DATA
+6) >> 8);
1086 opr_buf
[1] = (u8
)((GTP_REG_CONFIG_DATA
+6) & 0xFF);
1088 ret
= gtp_i2c_read(client
, opr_buf
, 3);
1093 int_type
= opr_buf
[2] & 0x03;
1095 GTP_INFO("X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
1096 abs_x_max
,abs_y_max
, int_type
);
1103 /*******************************************************
1105 GTP initialize function.
1108 client: i2c client private struct.
1111 Executive outcomes.0---succeed.
1112 *******************************************************/
1113 static s32
gtp_init_panel(struct i2c_client
*client
)
1117 #if GTP_DRIVER_SEND_CFG
1123 u8 cfg_info_group1
[] = CTP_CFG_GROUP1
;
1124 u8 cfg_info_group2
[] = CTP_CFG_GROUP2
;
1125 u8 cfg_info_group3
[] = CTP_CFG_GROUP3
;
1126 u8 cfg_info_group4
[] = CTP_CFG_GROUP4
;
1127 u8 cfg_info_group5
[] = CTP_CFG_GROUP5
;
1128 u8 cfg_info_group6
[] = CTP_CFG_GROUP6
;
1129 u8
*send_cfg_buf
[] = {cfg_info_group1
, cfg_info_group2
, cfg_info_group3
,
1130 cfg_info_group4
, cfg_info_group5
, cfg_info_group6
};
1131 u8 cfg_info_len
[] = { CFG_GROUP_LEN(cfg_info_group1
),
1132 CFG_GROUP_LEN(cfg_info_group2
),
1133 CFG_GROUP_LEN(cfg_info_group3
),
1134 CFG_GROUP_LEN(cfg_info_group4
),
1135 CFG_GROUP_LEN(cfg_info_group5
),
1136 CFG_GROUP_LEN(cfg_info_group6
)};
1138 GTP_DEBUG("Config Groups\' Lengths: %d, %d, %d, %d, %d, %d",
1139 cfg_info_len
[0], cfg_info_len
[1], cfg_info_len
[2], cfg_info_len
[3],
1140 cfg_info_len
[4], cfg_info_len
[5]);
1142 if ((!cfg_info_len
[1]) && (!cfg_info_len
[2]) &&
1143 (!cfg_info_len
[3]) && (!cfg_info_len
[4]) &&
1150 #if GTP_COMPATIBLE_MODE
1151 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
1156 ret
= gtp_i2c_read_dbl_check(client
, GTP_REG_SENSOR_ID
, &sensor_id
, 1);
1159 if (sensor_id
>= 0x06)
1161 GTP_ERROR("Invalid sensor_id(0x%02X), No Config Sent!", sensor_id
);
1164 #if GTP_COMPATIBLE_MODE
1165 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
1172 gtp_get_info(client
);
1179 GTP_ERROR("Failed to get sensor_id, No config sent!");
1183 GTP_INFO("Sensor_ID: %d", sensor_id
);
1186 cfg_len
= cfg_info_len
[sensor_id
];
1188 GTP_INFO("CTP_CONFIG_GROUP%d used, config length: %d", sensor_id
+ 1, cfg_len
);
1190 if (cfg_len
< GTP_CONFIG_MIN_LENGTH
)
1192 GTP_ERROR("CTP_CONFIG_GROUP%d is INVALID CONFIG GROUP! NO Config Sent! You need to check you header file CFG_GROUP section!", sensor_id
+1);
1197 #if GTP_COMPATIBLE_MODE
1198 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
1205 ret
= gtp_i2c_read_dbl_check(client
, GTP_REG_CONFIG_DATA
, &opr_buf
[0], 1);
1209 GTP_DEBUG("CFG_CONFIG_GROUP%d Config Version: %d, 0x%02X; IC Config Version: %d, 0x%02X", sensor_id
+1,
1210 send_cfg_buf
[sensor_id
][0], send_cfg_buf
[sensor_id
][0], opr_buf
[0], opr_buf
[0]);
1212 if (opr_buf
[0] < 90)
1214 grp_cfg_version
= send_cfg_buf
[sensor_id
][0]; // backup group config version
1215 send_cfg_buf
[sensor_id
][0] = 0x00;
1218 else // treated as fixed config, not send config
1220 GTP_INFO("Ic fixed config with config version(%d)", opr_buf
[0]);
1226 GTP_ERROR("Failed to get ic config version!No config sent!");
1231 memset(&config
[GTP_ADDR_LENGTH
], 0, GTP_CONFIG_MAX_LENGTH
);
1232 memcpy(&config
[GTP_ADDR_LENGTH
], send_cfg_buf
[sensor_id
], cfg_len
);
1235 config
[RESOLUTION_LOC
] = (u8
)GTP_MAX_WIDTH
;
1236 config
[RESOLUTION_LOC
+ 1] = (u8
)(GTP_MAX_WIDTH
>>8);
1237 config
[RESOLUTION_LOC
+ 2] = (u8
)GTP_MAX_HEIGHT
;
1238 config
[RESOLUTION_LOC
+ 3] = (u8
)(GTP_MAX_HEIGHT
>>8);
1240 if (GTP_INT_TRIGGER
== 0) //RISING
1242 config
[TRIGGER_LOC
] &= 0xfe;
1244 else if (GTP_INT_TRIGGER
== 1) //FALLING
1246 config
[TRIGGER_LOC
] |= 0x01;
1248 #endif // GTP_CUSTOM_CFG
1251 for (i
= GTP_ADDR_LENGTH
; i
< cfg_len
; i
++)
1253 check_sum
+= config
[i
];
1255 config
[cfg_len
] = (~check_sum
) + 1;
1257 #else // DRIVER NOT SEND CONFIG
1258 cfg_len
= GTP_CONFIG_MAX_LENGTH
;
1259 ret
= gtp_i2c_read(client
, config
, cfg_len
+ GTP_ADDR_LENGTH
);
1262 GTP_ERROR("Read Config Failed, Using DEFAULT Resolution & INT Trigger!");
1263 abs_x_max
= GTP_MAX_WIDTH
;
1264 abs_y_max
= GTP_MAX_HEIGHT
;
1265 int_type
= GTP_INT_TRIGGER
;
1267 #endif // GTP_DRIVER_SEND_CFG
1270 if ((abs_x_max
== 0) && (abs_y_max
== 0))
1272 abs_x_max
= (config
[RESOLUTION_LOC
+ 1] << 8) + config
[RESOLUTION_LOC
];
1273 abs_y_max
= (config
[RESOLUTION_LOC
+ 3] << 8) + config
[RESOLUTION_LOC
+ 2];
1274 int_type
= (config
[TRIGGER_LOC
]) & 0x03;
1277 #if GTP_COMPATIBLE_MODE
1278 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
1281 if (!memcmp(>p_default_FW_fl
[4], "950", 3))
1283 driver_num
= config
[GTP_REG_MATRIX_DRVNUM
- GTP_REG_CONFIG_DATA
+ 2];
1284 sensor_num
= config
[GTP_REG_MATRIX_SENNUM
- GTP_REG_CONFIG_DATA
+ 2];
1288 driver_num
= (config
[CFG_LOC_DRVA_NUM
]&0x1F) + (config
[CFG_LOC_DRVB_NUM
]&0x1F);
1289 sensor_num
= (config
[CFG_LOC_SENS_NUM
]&0x0F) + ((config
[CFG_LOC_SENS_NUM
]>>4)&0x0F);
1292 have_key
= config
[GTP_REG_HAVE_KEY
- GTP_REG_CONFIG_DATA
+ 2] & 0x01; // have key or not
1298 GTP_INFO("Driver * Sensor: %d * %d(Key: %d), X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
1299 driver_num
, sensor_num
, have_key
, abs_x_max
,abs_y_max
,int_type
);
1304 #if GTP_DRIVER_SEND_CFG
1305 ret
= gtp_send_cfg(client
);
1308 GTP_ERROR("Send config error.");
1310 // set config version to CTP_CFG_GROUP
1311 // for resume to send config
1312 config
[GTP_ADDR_LENGTH
] = grp_cfg_version
;
1314 for (i
= GTP_ADDR_LENGTH
; i
< cfg_len
; i
++)
1316 check_sum
+= config
[i
];
1318 config
[cfg_len
] = (~check_sum
) + 1;
1320 GTP_INFO("X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
1321 abs_x_max
,abs_y_max
,int_type
);
1328 static s8
gtp_i2c_test(struct i2c_client
*client
)
1339 ret
= i2c_read_bytes(client
, GTP_REG_HW_INFO
, (u8
*)&hw_info
, sizeof(hw_info
));
1341 if ((!ret
) && (hw_info
== 0x00900600)) //20121212
1346 GTP_ERROR("GTP_REG_HW_INFO : %08X", hw_info
);
1347 GTP_ERROR("GTP i2c test failed time %d.", retry
);
1356 /*******************************************************
1358 Set INT pin as input for FW sync.
1361 If the INT is high, It means there is pull up resistor attached on the INT pin.
1362 Pull low the INT pin manaully for FW sync.
1363 *******************************************************/
1364 void gtp_int_sync(s32 ms
)
1366 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
1368 GTP_GPIO_AS_INT(GTP_INT_PORT
);
1371 void gtp_reset_guitar(struct i2c_client
*client
, s32 ms
)
1373 GTP_INFO("GTP RESET!\n");
1374 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
1376 GTP_GPIO_OUTPUT(GTP_INT_PORT
, client
->addr
== 0x14);
1379 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 1);
1381 msleep(6); //must >= 6ms
1383 #if GTP_COMPATIBLE_MODE
1384 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
1390 gtp_int_sync(100); // for dbl-system
1392 gtp_init_ext_watchdog(i2c_client_point
);
1396 static int tpd_power_on(struct i2c_client
*client
)
1399 int reset_count
= 0;
1402 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
1403 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
1406 #ifdef TPD_POWER_SOURCE_CUSTOM
1407 hwPowerOn(TPD_POWER_SOURCE_CUSTOM
, VOL_2800
, "TP");
1409 hwPowerOn(MT65XX_POWER_LDO_VGP2
, VOL_2800
, "TP");
1411 #ifdef TPD_POWER_SOURCE_1800
1412 hwPowerOn(TPD_POWER_SOURCE_1800
, VOL_1800
, "TP");
1415 gtp_reset_guitar(client
, 20);
1417 #if GTP_COMPATIBLE_MODE
1418 gtp_get_chip_type(client
);
1420 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
1422 ret
= (int)gup_load_main_system(NULL
);
1425 GTP_ERROR("[tpd_power_on]Download fw failed.");
1426 if(reset_count
++ < TPD_MAX_RESET_COUNT
)
1439 ret
= gtp_i2c_test(client
);
1443 GTP_ERROR("I2C communication ERROR!");
1445 if (reset_count
< TPD_MAX_RESET_COUNT
)
1456 //**************** For GT9XXF Start ********************//
1457 #if GTP_COMPATIBLE_MODE
1459 void gtp_get_chip_type(struct i2c_client
*client
)
1461 u8 opr_buf
[10] = {0x00};
1466 ret
= gtp_i2c_read_dbl_check(client
, GTP_REG_CHIP_TYPE
, opr_buf
, 10);
1470 GTP_ERROR("Failed to get chip-type, set chip type default: GOODIX_GT9");
1471 gtp_chip_type
= CHIP_TYPE_GT9
;
1475 if (!memcmp(opr_buf
, "GOODIX_GT9", 10))
1477 GTP_INFO("Chip Type: %s", (gtp_chip_type
== CHIP_TYPE_GT9
) ? "GOODIX_GT9" : "GOODIX_GT9F");
1478 gtp_chip_type
= CHIP_TYPE_GT9
;
1482 gtp_chip_type
= CHIP_TYPE_GT9F
;
1483 GTP_INFO("Chip Type: %s", (gtp_chip_type
== CHIP_TYPE_GT9
) ? "GOODIX_GT9" : "GOODIX_GT9F");
1485 gtp_chip_type
= CHIP_TYPE_GT9
; // for test
1486 GTP_INFO("Chip Type: %s", (gtp_chip_type
== CHIP_TYPE_GT9
) ? "GOODIX_GT9" : "GOODIX_GT9F");
1489 static u8
gtp_bak_ref_proc(struct i2c_client
*client
, u8 mode
)
1494 struct file
*flp
= NULL
;
1497 u32 ref_seg_len
= 0;
1502 GTP_DEBUG("[gtp_bak_ref_proc]Driver:%d,Sensor:%d.", driver_num
, sensor_num
);
1504 //check file-system mounted
1505 GTP_DEBUG("[gtp_bak_ref_proc]Waiting for FS %d", gtp_ref_retries
);
1506 if (gup_check_fs_mounted("/data") == FAIL
)
1508 GTP_DEBUG("[gtp_bak_ref_proc]/data not mounted");
1509 if(gtp_ref_retries
++ < GTP_CHK_FS_MNT_MAX
)
1516 GTP_DEBUG("[gtp_bak_ref_proc]/data mounted !!!!");
1519 if (!memcmp(>p_default_FW_fl
[4], "950", 3))
1521 ref_seg_len
= (driver_num
* (sensor_num
- 1) + 2) * 2;
1523 ref_len
= ref_seg_len
* 6; // for GT950, backup-reference for six segments
1527 ref_len
= driver_num
*(sensor_num
-2)*2 + 4;
1528 ref_seg_len
= ref_len
;
1532 refp
= (u8
*)kzalloc(ref_len
, GFP_KERNEL
);
1535 GTP_ERROR("[gtp_bak_ref_proc]Alloc memory for ref failed.use default ref");
1538 memset(refp
, 0, ref_len
);
1539 if(gtp_ref_retries
>= GTP_CHK_FS_MNT_MAX
)
1541 for (j
= 0; j
< ref_grps
; ++j
)
1543 refp
[ref_seg_len
+ j
* ref_seg_len
-1] = 0x01;
1545 ret
= i2c_write_bytes(client
, 0x99D0, refp
, ref_len
);
1548 GTP_ERROR("[gtp_bak_ref_proc]Write ref i2c error.");
1552 GTP_ERROR("[gtp_bak_ref_proc]Bak file or path is not exist,send default ref.");
1558 flp
= filp_open(GTP_BAK_REF_PATH
, O_RDWR
| O_CREAT
, 0660);
1561 GTP_ERROR("[gtp_bak_ref_proc]Ref File not found!Creat ref file.");
1562 //flp->f_op->llseek(flp, 0, SEEK_SET);
1563 //flp->f_op->write(flp, (char *)refp, ref_len, &flp->f_pos);
1568 else if(GTP_BAK_REF_SEND
== mode
)
1570 flp
->f_op
->llseek(flp
, 0, SEEK_SET
);
1571 ret
= flp
->f_op
->read(flp
, (char *)refp
, ref_len
, &flp
->f_pos
);
1574 GTP_ERROR("[gtp_bak_ref_proc]Read ref file failed.");
1575 memset(refp
, 0, ref_len
);
1579 if(GTP_BAK_REF_STORE
== mode
)
1581 ret
= i2c_read_bytes(client
, 0x99D0, refp
, ref_len
);
1584 GTP_ERROR("[gtp_bak_ref_proc]Read ref i2c error.");
1588 flp
->f_op
->llseek(flp
, 0, SEEK_SET
);
1589 flp
->f_op
->write(flp
, (char *)refp
, ref_len
, &flp
->f_pos
);
1594 for (j
= 0; j
< ref_grps
; ++j
)
1597 for(i
=0; i
<ref_seg_len
-2; i
+=2)
1599 ref_chksum
+= ((refp
[i
+ j
* ref_seg_len
]<<8) + refp
[i
+ 1 + j
* ref_seg_len
]);
1602 GTP_DEBUG("[gtp_bak_ref_proc]Calc ref chksum:0x%04X", ref_chksum
&0xFF);
1603 tmp
= ref_chksum
+ (refp
[ref_seg_len
+ j
* ref_seg_len
-2]<<8) + refp
[ref_seg_len
+ j
* ref_seg_len
-1];
1606 GTP_DEBUG("[gtp_bak_ref_proc]Ref file chksum error,use default ref");
1607 memset(&refp
[j
* ref_seg_len
], 0, ref_seg_len
);
1608 refp
[ref_seg_len
- 1 + j
* ref_seg_len
] = 0x01;
1612 if (j
== (ref_grps
- 1))
1614 GTP_DEBUG("[gtp_bak_ref_proc]Ref file chksum success.");
1620 ret
= i2c_write_bytes(client
, 0x99D0, refp
, ref_len
);
1623 GTP_ERROR("[gtp_bak_ref_proc]Write ref i2c error.");
1636 if (flp
&& !IS_ERR(flp
))
1638 filp_close(flp
, NULL
);
1643 u8
gtp_fw_startup(struct i2c_client
*client
)
1650 ret
= i2c_write_bytes(client
, 0x8041, wr_buf
, 1);
1653 GTP_ERROR("I2C error to firmware startup.");
1656 //release SS51 & DSP
1658 i2c_write_bytes(client
, 0x4180, wr_buf
, 1);
1663 //check fw run status
1664 i2c_read_bytes(client
, 0x8041, wr_buf
, 1);
1665 if(0xAA == wr_buf
[0])
1667 GTP_ERROR("IC works abnormally,startup failed.");
1672 GTP_DEBUG("IC works normally,Startup success.");
1674 i2c_write_bytes(client
, 0x8041, wr_buf
, 1);
1679 static void gtp_recovery_reset(struct i2c_client
*client
)
1681 mutex_lock(&i2c_access
);
1685 gtp_esd_switch(client
, SWITCH_OFF
);
1687 force_reset_guitar();
1689 gtp_esd_switch(client
, SWITCH_ON
);
1692 mutex_unlock(&i2c_access
);
1695 static u8
gtp_check_clk_legality(void)
1698 u8 clk_chksum
= gtp_clk_buf
[5];
1700 for(i
= 0; i
< 5; i
++)
1702 if((gtp_clk_buf
[i
] < 50) || (gtp_clk_buf
[i
] > 120) ||
1703 (gtp_clk_buf
[i
] != gtp_clk_buf
[0]))
1707 clk_chksum
+= gtp_clk_buf
[i
];
1710 if((i
== 5) && (clk_chksum
== 0))
1712 GTP_INFO("Clk ram legality check success");
1715 GTP_ERROR("main clock freq in clock buf is wrong");
1719 static u8
gtp_main_clk_proc(struct i2c_client
*client
)
1723 u8 clk_cal_result
= 0;
1725 struct file
*flp
= NULL
;
1727 //check clk legality
1728 ret
= gtp_check_clk_legality();
1734 GTP_DEBUG("[gtp_main_clk_proc]Waiting for FS %d", gtp_ref_retries
);
1735 if (gup_check_fs_mounted("/data") == FAIL
)
1737 GTP_DEBUG("[gtp_main_clk_proc]/data not mounted");
1738 if(gtp_clk_retries
++ < GTP_CHK_FS_MNT_MAX
)
1744 GTP_ERROR("[gtp_main_clk_proc]Wait for file system timeout,need cal clk");
1749 GTP_DEBUG("[gtp_main_clk_proc]/data mounted !!!!");
1750 flp
= filp_open(GTP_MAIN_CLK_PATH
, O_RDWR
| O_CREAT
, 0660);
1753 flp
->f_op
->llseek(flp
, 0, SEEK_SET
);
1754 ret
= flp
->f_op
->read(flp
, (char *)gtp_clk_buf
, 6, &flp
->f_pos
);
1757 ret
= gtp_check_clk_legality();
1760 GTP_DEBUG("[gtp_main_clk_proc]Open & read & check clk file success.");
1765 GTP_ERROR("[gtp_main_clk_proc]Check clk file failed,need cal clk");
1770 gtp_esd_switch(client
, SWITCH_OFF
);
1772 clk_cal_result
= gup_clk_calibration();
1773 force_reset_guitar();
1774 GTP_DEBUG("&&&&&&&&&&clk cal result:%d", clk_cal_result
);
1777 gtp_esd_switch(client
, SWITCH_ON
);
1780 if(clk_cal_result
< 50 || clk_cal_result
> 120)
1782 GTP_ERROR("[gtp_main_clk_proc]cal clk result is illegitimate");
1787 for(i
= 0;i
< 5; i
++)
1789 gtp_clk_buf
[i
] = clk_cal_result
;
1790 clk_chksum
+= gtp_clk_buf
[i
];
1792 gtp_clk_buf
[5] = 0 - clk_chksum
;
1796 flp
= filp_open(GTP_MAIN_CLK_PATH
, O_RDWR
| O_CREAT
, 0660);
1800 flp
->f_op
->llseek(flp
, 0, SEEK_SET
);
1801 flp
->f_op
->write(flp
, (char *)gtp_clk_buf
, 6, &flp
->f_pos
);
1807 ret
= i2c_write_bytes(client
, 0x8020, gtp_clk_buf
, 6);
1810 GTP_ERROR("[gtp_main_clk_proc]send main clk i2c error!");
1818 if (flp
&& !IS_ERR(flp
))
1820 filp_close(flp
, NULL
);
1826 //************* For GT9XXF End **********************//
1828 static const struct file_operations gt_upgrade_proc_fops
= {
1829 .write
= gt91xx_config_write_proc
,
1830 .read
= gt91xx_config_read_proc
1833 static s32
tpd_i2c_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
1839 #if GTP_HAVE_TOUCH_KEY
1842 #ifdef TPD_PROXIMITY
1843 struct hwmsen_object obj_ps
;
1846 i2c_client_point
= client
;
1847 ret
= tpd_power_on(client
);
1851 GTP_ERROR("I2C communication ERROR!");
1854 //#ifdef VELOCITY_CUSTOM
1857 if ((err
= misc_register(&tpd_misc_device
)))
1859 printk("mtk_tpd: tpd_misc_device register failed\n");
1863 #ifdef VELOCITY_CUSTOM
1864 tpd_v_magnify_x
= TPD_VELOCITY_CUSTOM_X
;
1865 tpd_v_magnify_y
= TPD_VELOCITY_CUSTOM_Y
;
1869 ret
= gtp_read_version(client
, &version_info
);
1873 GTP_ERROR("Read version failed.");
1876 ret
= gtp_init_panel(client
);
1880 GTP_ERROR("GTP init panel failed.");
1883 // Create proc file system
1884 gt91xx_config_proc
= proc_create(GT91XX_CONFIG_PROC_FILE
, 0660, NULL
, >_upgrade_proc_fops
);
1885 if (gt91xx_config_proc
== NULL
)
1887 GTP_ERROR("create_proc_entry %s failed\n", GT91XX_CONFIG_PROC_FILE
);
1891 #if GTP_CREATE_WR_NODE
1892 init_wr_node(client
);
1895 thread
= kthread_run(touch_event_handler
, 0, TPD_DEVICE
);
1899 err
= PTR_ERR(thread
);
1900 GTP_INFO(TPD_DEVICE
" failed to create kernel thread: %d\n", err
);
1904 #if GTP_HAVE_TOUCH_KEY
1906 for (idx
= 0; idx
< GTP_MAX_KEY_NUM
; idx
++)
1908 input_set_capability(tpd
->dev
, EV_KEY
, touch_key_array
[idx
]);
1912 #if GTP_SLIDE_WAKEUP
1913 input_set_capability(tpd
->dev
, EV_KEY
, KEY_POWER
);
1918 __set_bit(BTN_TOOL_PEN
, tpd
->dev
->keybit
);
1919 __set_bit(INPUT_PROP_DIRECT
, tpd
->dev
->propbit
);
1920 //__set_bit(INPUT_PROP_POINTER, tpd->dev->propbit); // 20130722
1923 mt_set_gpio_mode(GPIO_CTP_EINT_PIN
, GPIO_CTP_EINT_PIN_M_EINT
);
1924 mt_set_gpio_dir(GPIO_CTP_EINT_PIN
, GPIO_DIR_IN
);
1925 mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN
, GPIO_PULL_DISABLE
);
1929 if (!int_type
) //EINTF_TRIGGER
1931 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM
, EINTF_TRIGGER_RISING
, tpd_eint_interrupt_handler
, 1);
1935 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM
, EINTF_TRIGGER_FALLING
, tpd_eint_interrupt_handler
, 1);
1938 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
1941 ret
= gup_init_update_proc(client
);
1945 GTP_ERROR("Create update thread error.");
1949 #ifdef TPD_PROXIMITY
1950 //obj_ps.self = cm3623_obj;
1951 obj_ps
.polling
= 0; //0--interrupt mode;1--polling mode;
1952 obj_ps
.sensor_operate
= tpd_ps_operate
;
1954 if ((err
= hwmsen_attach(ID_PROXIMITY
, &obj_ps
)))
1956 GTP_ERROR("hwmsen attach fail, return:%d.", err
);
1962 gtp_esd_switch(client
, SWITCH_ON
);
1965 tpd_load_status
= 1;
1970 static void tpd_eint_interrupt_handler(void)
1972 TPD_DEBUG_PRINT_INT
;
1976 wake_up_interruptible(&waiter
);
1978 static int tpd_i2c_remove(struct i2c_client
*client
)
1980 #if GTP_CREATE_WR_NODE
1985 destroy_workqueue(gtp_esd_check_workqueue
);
1990 #if (GTP_ESD_PROTECT || GTP_COMPATIBLE_MODE)
1991 void force_reset_guitar(void)
1995 //static u8 is_reseting = 0;
1997 if(is_reseting
|| (load_fw_process
== 1))
2001 GTP_INFO("force_reset_guitar");
2003 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
2005 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
2006 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
2009 #ifdef TPD_POWER_SOURCE_CUSTOM
2010 hwPowerDown(TPD_POWER_SOURCE_CUSTOM
, "TP");
2012 hwPowerDown(MT65XX_POWER_LDO_VGP2
, "TP");
2014 #ifdef TPD_POWER_SOURCE_1800
2015 hwPowerDown(TPD_POWER_SOURCE_1800
, "TP");
2020 #ifdef TPD_POWER_SOURCE_CUSTOM
2021 hwPowerOn(TPD_POWER_SOURCE_CUSTOM
, VOL_2800
, "TP");
2023 hwPowerOn(MT65XX_POWER_LDO_VGP2
, VOL_2800
, "TP");
2027 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
2029 for (i
= 0; i
< 5; i
++)
2032 gtp_reset_guitar(i2c_client_point
, 20);
2034 #if GTP_COMPATIBLE_MODE
2035 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
2038 ret
= gup_load_main_system(NULL
);
2041 GTP_ERROR("[force_reset_guitar]Check & repair fw failed.");
2049 ret
= gtp_send_cfg(i2c_client_point
);
2064 static s32
gtp_init_ext_watchdog(struct i2c_client
*client
)
2066 u8 opr_buffer
[2] = {0xAA};
2067 GTP_DEBUG("Init external watchdog.");
2068 return i2c_write_bytes(client
, 0x8041, opr_buffer
, 1);
2071 void gtp_esd_switch(struct i2c_client
*client
, s32 on
)
2073 spin_lock(&esd_lock
);
2074 if (SWITCH_ON
== on
) // switch on esd
2079 spin_unlock(&esd_lock
);
2080 GTP_INFO("Esd started");
2081 queue_delayed_work(gtp_esd_check_workqueue
, >p_esd_check_work
, clk_tick_cnt
);
2085 spin_unlock(&esd_lock
);
2088 else // switch off esd
2093 spin_unlock(&esd_lock
);
2094 GTP_INFO("Esd cancelled");
2095 cancel_delayed_work(>p_esd_check_work
);
2099 spin_unlock(&esd_lock
);
2105 static void gtp_esd_check_func(struct work_struct
*work
)
2109 u8 esd_buf
[2] = {0x00};
2113 GTP_INFO("Esd suspended!");
2116 if(1 == load_fw_process
)
2118 GTP_INFO("Load FW process is runing");
2121 for (i
= 0; i
< 3; i
++)
2123 ret
= i2c_read_bytes_non_dma(i2c_client_point
, 0x8040, esd_buf
, 2);
2125 GTP_DEBUG("[Esd]0x8040 = 0x%02X, 0x8041 = 0x%02X", esd_buf
[0], esd_buf
[1]);
2128 // IIC communication problem
2133 if ((esd_buf
[0] == 0xAA) || (esd_buf
[1] != 0xAA))
2135 u8 chk_buf
[2] = {0x00};
2136 i2c_read_bytes_non_dma(i2c_client_point
, 0x8040, chk_buf
, 2);
2138 GTP_DEBUG("[Check]0x8040 = 0x%02X, 0x8041 = 0x%02X", chk_buf
[0], chk_buf
[1]);
2140 if ( (chk_buf
[0] == 0xAA) || (chk_buf
[1] != 0xAA) )
2142 i
= 3; // jump to reset guitar
2152 // IC works normally, Write 0x8040 0xAA, feed the watchdog
2154 i2c_write_bytes_non_dma(i2c_client_point
, 0x8040, esd_buf
, 1);
2163 #if GTP_COMPATIBLE_MODE
2164 if ((CHIP_TYPE_GT9F
== gtp_chip_type
) && (1 == rqst_processing
))
2166 GTP_INFO("Request Processing, no reset guitar.");
2171 GTP_INFO("IC works abnormally! Process reset guitar.");
2172 memset(esd_buf
, 0x01, sizeof(esd_buf
));
2173 i2c_write_bytes(i2c_client_point
, 0x4226, esd_buf
, sizeof(esd_buf
));
2175 force_reset_guitar();
2179 #if FLASHLESS_FLASH_WORKROUND
2187 ret
= i2c_read_bytes_non_dma(i2c_client_point
, 0x8140, versionBuff
, sizeof(versionBuff
));
2193 if( memcmp(versionBuff
, >p_default_FW_fl
[4], 4) !=0 )
2197 temp
= versionBuff
[5];
2198 versionBuff
[5] = versionBuff
[4];
2199 versionBuff
[4] = temp
;
2201 if( memcmp(&versionBuff
[4], >p_default_FW_fl
[12], 2) !=0 )
2209 GTP_INFO("IC version error., force reset!");
2210 force_reset_guitar();
2217 queue_delayed_work(gtp_esd_check_workqueue
, >p_esd_check_work
, clk_tick_cnt
);
2221 GTP_INFO("Esd suspended!");
2227 static int tpd_history_x
=0, tpd_history_y
=0;
2228 static void tpd_down(s32 x
, s32 y
, s32 size
, s32 id
)
2230 if ((!size
) && (!id
))
2232 input_report_abs(tpd
->dev
, ABS_MT_PRESSURE
, 100);
2233 input_report_abs(tpd
->dev
, ABS_MT_TOUCH_MAJOR
, 100);
2237 input_report_abs(tpd
->dev
, ABS_MT_PRESSURE
, size
);
2238 input_report_abs(tpd
->dev
, ABS_MT_TOUCH_MAJOR
, size
);
2239 /* track id Start 0 */
2240 input_report_abs(tpd
->dev
, ABS_MT_TRACKING_ID
, id
);
2243 input_report_key(tpd
->dev
, BTN_TOUCH
, 1);
2244 input_report_abs(tpd
->dev
, ABS_MT_POSITION_X
, x
);
2245 input_report_abs(tpd
->dev
, ABS_MT_POSITION_Y
, y
);
2246 input_mt_sync(tpd
->dev
);
2248 TPD_EM_PRINT(x
, y
, x
, y
, id
, 1);
2252 //MMProfileLogEx(MMP_TouchPanelEvent, MMProfileFlagPulse, 1, x+y);
2253 #ifdef TPD_HAVE_BUTTON
2255 if (FACTORY_BOOT
== get_boot_mode() || RECOVERY_BOOT
== get_boot_mode())
2257 tpd_button(x
, y
, 1);
2263 static void tpd_up(s32 x
, s32 y
, s32 id
)
2265 //input_report_abs(tpd->dev, ABS_MT_PRESSURE, 0);
2266 input_report_key(tpd
->dev
, BTN_TOUCH
, 0);
2267 //input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 0);
2268 input_mt_sync(tpd
->dev
);
2270 TPD_EM_PRINT(tpd_history_x
, tpd_history_y
, tpd_history_x
, tpd_history_y
, id
, 0);
2273 //MMProfileLogEx(MMP_TouchPanelEvent, MMProfileFlagPulse, 0, x+y);
2275 #ifdef TPD_HAVE_BUTTON
2277 if (FACTORY_BOOT
== get_boot_mode() || RECOVERY_BOOT
== get_boot_mode())
2279 tpd_button(x
, y
, 0);
2284 #if GTP_CHARGER_SWITCH
2285 static void gtp_charger_switch(s32 dir_update
)
2288 u8 chr_cmd
[3] = {0x80, 0x40};
2289 static u8 chr_pluggedin
= 0;
2292 chr_status
= upmu_is_chr_det();
2294 if (chr_status
) // charger plugged in
2296 if (!chr_pluggedin
|| dir_update
)
2299 ret
= gtp_i2c_write(i2c_client_point
, chr_cmd
, 3);
2302 GTP_INFO("Update status for Charger Plugin");
2307 else // charger plugged out
2309 if (chr_pluggedin
|| dir_update
)
2312 ret
= gtp_i2c_write(i2c_client_point
, chr_cmd
, 3);
2315 GTP_INFO("Update status for Charger Plugout");
2323 /*Coordination mapping*/
2324 static void tpd_calibrate_driver(int *x
, int *y
)
2328 GTP_DEBUG("Call tpd_calibrate of this driver ..\n");
2330 tx
= ( (tpd_def_calmat
[0] * (*x
)) + (tpd_def_calmat
[1] * (*y
)) + (tpd_def_calmat
[2]) ) >> 12;
2331 *y
= ( (tpd_def_calmat
[3] * (*x
)) + (tpd_def_calmat
[4] * (*y
)) + (tpd_def_calmat
[5]) ) >> 12;
2335 static int touch_event_handler(void *unused
)
2337 struct sched_param param
= { .sched_priority
= RTPM_PRIO_TPD
};
2338 u8 end_cmd
[3] = {GTP_READ_COOR_ADDR
>> 8, GTP_READ_COOR_ADDR
& 0xFF, 0};
2339 u8 point_data
[2 + 1 + 8 * GTP_MAX_TOUCH
+ 1] = {GTP_READ_COOR_ADDR
>> 8, GTP_READ_COOR_ADDR
& 0xFF};
2342 static u8 pre_touch
= 0;
2343 static u8 pre_key
= 0;
2345 static u8 pre_pen
= 0;
2348 u8
*coor_data
= NULL
;
2356 #if GTP_COMPATIBLE_MODE
2357 u8 rqst_data
[3] = {(u8
)(GTP_REG_RQST
>> 8), (u8
)(GTP_REG_RQST
& 0xFF), 0};
2360 #if HOTKNOT_BLOCK_RW
2361 u8 hn_pxy_state
= 0;
2362 u8 hn_pxy_state_bak
= 0;
2363 u8 hn_paired_cnt
= 0;
2364 u8 hn_state_buf
[10] = {(u8
)(GTP_REG_HN_STATE
>> 8), (u8
)(GTP_REG_HN_STATE
& 0xFF), 0};
2367 #ifdef TPD_PROXIMITY
2369 hwm_sensor_data sensor_data
;
2370 u8 proximity_status
;
2373 #if GTP_SLIDE_WAKEUP
2374 u8 doze_buf
[3] = {0x81, 0x4B};
2377 sched_setscheduler(current
, SCHED_RR
, ¶m
);
2380 set_current_state(TASK_INTERRUPTIBLE
);
2383 wait_event_interruptible(waiter
, tpd_flag
!= 0);
2388 msleep(tpd_polling_time
);
2391 set_current_state(TASK_RUNNING
);
2392 mutex_lock(&i2c_access
);
2393 #if GTP_CHARGER_SWITCH
2394 gtp_charger_switch(0);
2397 #if GTP_SLIDE_WAKEUP
2398 if (DOZE_ENABLED
== doze_status
)
2400 ret
= gtp_i2c_read(i2c_client_point
, doze_buf
, 3);
2401 GTP_DEBUG("0x814B = 0x%02X", doze_buf
[2]);
2404 if (0xAA == doze_buf
[2])
2406 GTP_INFO("Forward slide to light up the screen!");
2407 doze_status
= DOZE_WAKEUP
;
2408 input_report_key(tpd
->dev
, KEY_POWER
, 1);
2409 input_sync(tpd
->dev
);
2410 input_report_key(tpd
->dev
, KEY_POWER
, 0);
2411 input_sync(tpd
->dev
);
2414 gtp_i2c_write(i2c_client_point
, doze_buf
, 3);
2416 else if (0xBB == doze_buf
[2])
2418 GTP_INFO("Backward slide to light up the screen!");
2419 doze_status
= DOZE_WAKEUP
;
2420 input_report_key(tpd
->dev
, KEY_POWER
, 1);
2421 input_sync(tpd
->dev
);
2422 input_report_key(tpd
->dev
, KEY_POWER
, 0);
2423 input_sync(tpd
->dev
);
2426 gtp_i2c_write(i2c_client_point
, doze_buf
, 3);
2429 else if (0xC0 == (doze_buf
[2] & 0xC0)) // double click wakeup
2431 GTP_INFO("Double click to light up the screen!");
2432 doze_status
= DOZE_WAKEUP
;
2433 input_report_key(tpd
->dev
, KEY_POWER
, 1);
2434 input_sync(tpd
->dev
);
2435 input_report_key(tpd
->dev
, KEY_POWER
, 0);
2436 input_sync(tpd
->dev
);
2439 gtp_i2c_write(i2c_client_point
, doze_buf
, 3);
2443 gtp_enter_doze(i2c_client_point
);
2449 if(tpd_halt
||(is_reseting
== 1) || (load_fw_process
== 1))
2451 mutex_unlock(&i2c_access
);
2452 GTP_DEBUG("return for interrupt after suspend... ");
2455 ret
= gtp_i2c_read(i2c_client_point
, point_data
, 12);
2458 GTP_ERROR("I2C transfer error. errno:%d\n ", ret
);
2459 goto exit_work_func
;
2461 finger
= point_data
[GTP_ADDR_LENGTH
];
2463 #if GTP_COMPATIBLE_MODE
2464 if ((finger
== 0x00) && (CHIP_TYPE_GT9F
== gtp_chip_type
))
2466 ret
= gtp_i2c_read(i2c_client_point
, rqst_data
, 3);
2470 GTP_ERROR("I2C transfer error. errno:%d\n ", ret
);
2471 goto exit_work_func
;
2473 switch(rqst_data
[2]&0x0F)
2475 case GTP_RQST_BAK_REF
:
2476 GTP_INFO("Request Ref.");
2477 ret
= gtp_bak_ref_proc(i2c_client_point
, GTP_BAK_REF_SEND
);
2480 GTP_INFO("Send ref success.");
2481 rqst_data
[2] = GTP_RQST_RESPONDED
;
2482 gtp_i2c_write(i2c_client_point
, rqst_data
, 3);
2484 goto exit_work_func
;
2485 case GTP_RQST_CONFIG
:
2486 GTP_INFO("Request Config.");
2487 ret
= gtp_send_cfg(i2c_client_point
);
2490 GTP_ERROR("Send config error.");
2494 GTP_INFO("Send config success.");
2495 rqst_data
[2] = GTP_RQST_RESPONDED
;
2496 gtp_i2c_write(i2c_client_point
, rqst_data
, 3);
2498 goto exit_work_func
;
2499 case GTP_RQST_MAIN_CLOCK
:
2500 GTP_INFO("Request main clock.");
2501 rqst_processing
= 1;
2502 ret
= gtp_main_clk_proc(i2c_client_point
);
2505 GTP_INFO("Send main clk success.");
2506 rqst_data
[2] = GTP_RQST_RESPONDED
;
2507 gtp_i2c_write(i2c_client_point
, rqst_data
, 3);
2508 rqst_processing
= 0;
2510 goto exit_work_func
;
2511 case GTP_RQST_RESET
:
2512 GTP_INFO("Request Reset.");
2513 gtp_recovery_reset(i2c_client_point
);
2514 goto exit_work_func
;
2515 case GTP_RQST_HOTKNOT_CODE
:
2516 GTP_INFO("Request HotKnot Code.");
2517 gup_load_hotknot_system();
2518 goto exit_work_func
;
2525 if ((finger
& 0x80) == 0)
2527 #if HOTKNOT_BLOCK_RW
2528 if(!hotknot_paired_flag
)
2531 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
2532 mutex_unlock(&i2c_access
);
2533 GTP_ERROR("buffer not ready");
2538 #if HOTKNOT_BLOCK_RW
2539 if(!hotknot_paired_flag
&& (finger
&0x0F))
2541 id
= point_data
[GTP_ADDR_LENGTH
+1];
2542 hn_pxy_state
= point_data
[GTP_ADDR_LENGTH
+2]&0x80;
2543 hn_pxy_state_bak
= point_data
[GTP_ADDR_LENGTH
+3]&0x80;
2544 if((32 == id
) && (0x80 == hn_pxy_state
) && (0x80 == hn_pxy_state_bak
))
2546 #ifdef HN_DBLCFM_PAIRED
2547 if(hn_paired_cnt
++ < 2)
2549 goto exit_work_func
;
2552 GTP_DEBUG("HotKnot paired!");
2553 if(wait_hotknot_state
& HN_DEVICE_PAIRED
)
2555 GTP_DEBUG("INT wakeup HN_DEVICE_PAIRED block polling waiter");
2556 got_hotknot_state
|= HN_DEVICE_PAIRED
;
2557 wake_up_interruptible(&bp_waiter
);
2559 hotknot_paired_flag
= 1;
2560 goto exit_work_func
;
2564 got_hotknot_state
&= (~HN_DEVICE_PAIRED
);
2570 if(hotknot_paired_flag
)
2572 ret
= gtp_i2c_read(i2c_client_point
, hn_state_buf
, 6);
2576 GTP_ERROR("I2C transfer error. errno:%d\n ", ret
);
2577 goto exit_work_func
;
2580 got_hotknot_state
= 0;
2582 GTP_DEBUG("[0xAB10~0xAB13]=0x%x,0x%x,0x%x,0x%x", hn_state_buf
[GTP_ADDR_LENGTH
],
2583 hn_state_buf
[GTP_ADDR_LENGTH
+1],
2584 hn_state_buf
[GTP_ADDR_LENGTH
+2],
2585 hn_state_buf
[GTP_ADDR_LENGTH
+3]);
2587 if(wait_hotknot_state
& HN_MASTER_SEND
)
2589 if((0x03 == hn_state_buf
[GTP_ADDR_LENGTH
]) ||
2590 (0x04 == hn_state_buf
[GTP_ADDR_LENGTH
]) ||
2591 (0x07 == hn_state_buf
[GTP_ADDR_LENGTH
]))
2593 GTP_DEBUG("Wakeup HN_MASTER_SEND block polling waiter");
2594 got_hotknot_state
|= HN_MASTER_SEND
;
2595 got_hotknot_extra_state
= hn_state_buf
[GTP_ADDR_LENGTH
];
2596 wake_up_interruptible(&bp_waiter
);
2599 else if(wait_hotknot_state
& HN_SLAVE_RECEIVED
)
2601 if((0x03 == hn_state_buf
[GTP_ADDR_LENGTH
+1]) ||
2602 (0x04 == hn_state_buf
[GTP_ADDR_LENGTH
+1]) ||
2603 (0x07 == hn_state_buf
[GTP_ADDR_LENGTH
+1]))
2605 GTP_DEBUG("Wakeup HN_SLAVE_RECEIVED block polling waiter:0x%x", hn_state_buf
[GTP_ADDR_LENGTH
+1]);
2606 got_hotknot_state
|= HN_SLAVE_RECEIVED
;
2607 got_hotknot_extra_state
= hn_state_buf
[GTP_ADDR_LENGTH
+1];
2608 wake_up_interruptible(&bp_waiter
);
2611 else if(wait_hotknot_state
& HN_MASTER_DEPARTED
)
2613 if(0x07 == hn_state_buf
[GTP_ADDR_LENGTH
])
2615 GTP_DEBUG("Wakeup HN_MASTER_DEPARTED block polling waiter");
2616 got_hotknot_state
|= HN_MASTER_DEPARTED
;
2617 wake_up_interruptible(&bp_waiter
);
2620 else if(wait_hotknot_state
& HN_SLAVE_DEPARTED
)
2622 if(0x07 == hn_state_buf
[GTP_ADDR_LENGTH
+1])
2624 GTP_DEBUG("Wakeup HN_SLAVE_DEPARTED block polling waiter");
2625 got_hotknot_state
|= HN_SLAVE_DEPARTED
;
2626 wake_up_interruptible(&bp_waiter
);
2633 #ifdef TPD_PROXIMITY
2634 if (tpd_proximity_flag
== 1)
2636 proximity_status
= point_data
[GTP_ADDR_LENGTH
];
2637 GTP_DEBUG("REG INDEX[0x814E]:0x%02X\n", proximity_status
);
2639 if (proximity_status
& 0x60) //proximity or large touch detect,enable hwm_sensor.
2641 tpd_proximity_detect
= 0;
2642 //sensor_data.values[0] = 0;
2646 tpd_proximity_detect
= 1;
2647 //sensor_data.values[0] = 1;
2651 GTP_DEBUG(" ps change\n");
2652 GTP_DEBUG("PROXIMITY STATUS:0x%02X\n", tpd_proximity_detect
);
2653 //map and store data to hwm_sensor_data
2654 sensor_data
.values
[0] = tpd_get_ps_value();
2655 sensor_data
.value_divide
= 1;
2656 sensor_data
.status
= SENSOR_STATUS_ACCURACY_MEDIUM
;
2657 //report to the up-layer
2658 ret
= hwmsen_get_interrupt_data(ID_PROXIMITY
, &sensor_data
);
2662 GTP_ERROR("Call hwmsen_get_interrupt_data fail = %d\n", err
);
2668 touch_num
= finger
& 0x0f;
2670 if (touch_num
> GTP_MAX_TOUCH
)
2672 GTP_ERROR("Bad number of fingers!");
2673 goto exit_work_func
;
2678 u8 buf
[8 * GTP_MAX_TOUCH
] = {(GTP_READ_COOR_ADDR
+ 10) >> 8, (GTP_READ_COOR_ADDR
+ 10) & 0xff};
2680 ret
= gtp_i2c_read(i2c_client_point
, buf
, 2 + 8 * (touch_num
- 1));
2681 memcpy(&point_data
[12], &buf
[2], 8 * (touch_num
- 1));
2684 #if GTP_HAVE_TOUCH_KEY
2685 key_value
= point_data
[3 + 8 * touch_num
];
2687 if (key_value
|| pre_key
)
2689 for (i
= 0; i
< TPD_KEY_COUNT
; i
++)
2691 //input_report_key(tpd->dev, touch_key_array[i], key_value & (0x01 << i));
2692 if( key_value
&(0x01<<i
) ) //key=1 menu ;key=2 home; key =4 back;
2694 input_x
=touch_key_point_maping_array
[i
].point_x
;
2695 input_y
= touch_key_point_maping_array
[i
].point_y
;
2696 GTP_DEBUG("button =%d %d",input_x
,input_y
);
2698 tpd_down( input_x
, input_y
, 0, 0);
2702 if((pre_key
!=0)&&(key_value
==0))
2712 pre_key
= key_value
;
2714 GTP_DEBUG("pre_touch:%02x, finger:%02x.", pre_touch
, finger
);
2718 for (i
= 0; i
< touch_num
; i
++)
2720 coor_data
= &point_data
[i
* 8 + 3];
2722 id
= coor_data
[0] & 0x0F;
2723 input_x
= coor_data
[1] | coor_data
[2] << 8;
2724 input_y
= coor_data
[3] | coor_data
[4] << 8;
2725 input_w
= coor_data
[5] | coor_data
[6] << 8;
2727 GTP_DEBUG("Original touch point : [X:%04d, Y:%04d]", input_x
, input_y
);
2729 input_x
= TPD_WARP_X(abs_x_max
, input_x
);
2730 input_y
= TPD_WARP_Y(abs_y_max
, input_y
);
2731 tpd_calibrate_driver(&input_x
, &input_y
);
2733 GTP_DEBUG("Touch point after calibration: [X:%04d, Y:%04d]", input_x
, input_y
);
2737 if ((id
& 0x80)) // pen/stylus is activated
2739 GTP_DEBUG("Pen touch DOWN!");
2740 input_report_key(tpd
->dev
, BTN_TOOL_PEN
, 1);
2745 GTP_DEBUG(" %d)(%d, %d)[%d]", id
, input_x
, input_y
, input_w
);
2746 tpd_down(input_x
, input_y
, input_w
, id
);
2754 GTP_DEBUG("Pen touch UP!");
2755 input_report_key(tpd
->dev
, BTN_TOOL_PEN
, 0);
2759 GTP_DEBUG("Touch Release!");
2764 GTP_DEBUG("Additional Eint!");
2766 pre_touch
= touch_num
;
2768 if (tpd
!= NULL
&& tpd
->dev
!= NULL
)
2770 input_sync(tpd
->dev
);
2775 if (!gtp_rawdiff_mode
)
2777 ret
= gtp_i2c_write(i2c_client_point
, end_cmd
, 3);
2781 GTP_INFO("I2C write end_cmd error!");
2784 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
2785 mutex_unlock(&i2c_access
);
2787 } while (!kthread_should_stop());
2792 static int tpd_local_init(void)
2795 clk_tick_cnt
= 2 * HZ
; // HZ: clock ticks in 1 second generated by system
2796 GTP_DEBUG("Clock ticks for an esd cycle: %d", clk_tick_cnt
);
2797 INIT_DELAYED_WORK(>p_esd_check_work
, gtp_esd_check_func
);
2798 gtp_esd_check_workqueue
= create_workqueue("gtp_esd_check");
2799 spin_lock_init(&esd_lock
); // 2.6.39 & later
2800 // esd_lock = SPIN_LOCK_UNLOCKED; // 2.6.39 & before
2803 #if GTP_SUPPORT_I2C_DMA
2804 gpDMABuf_va
= (u8
*)dma_alloc_coherent(NULL
, GTP_DMA_MAX_TRANSACTION_LENGTH
, &gpDMABuf_pa
, GFP_KERNEL
);
2806 GTP_INFO("[Error] Allocate DMA I2C Buffer failed!\n");
2808 memset(gpDMABuf_va
, 0, GTP_DMA_MAX_TRANSACTION_LENGTH
);
2810 if (i2c_add_driver(&tpd_i2c_driver
) != 0)
2812 GTP_INFO("unable to add i2c driver.\n");
2816 if (tpd_load_status
== 0) //if(tpd_load_status == 0) // disable auto load touch driver for linux3.0 porting
2818 GTP_INFO("add error touch panel driver.\n");
2819 i2c_del_driver(&tpd_i2c_driver
);
2822 input_set_abs_params(tpd
->dev
, ABS_MT_TRACKING_ID
, 0, (GTP_MAX_TOUCH
-1), 0, 0);
2823 #ifdef TPD_HAVE_BUTTON
2824 tpd_button_setting(TPD_KEY_COUNT
, tpd_keys_local
, tpd_keys_dim_local
);// initialize tpd button data
2827 #if (defined(TPD_WARP_START) && defined(TPD_WARP_END))
2829 memcpy(tpd_wb_start
, tpd_wb_start_local
, TPD_WARP_CNT
* 4);
2830 memcpy(tpd_wb_end
, tpd_wb_start_local
, TPD_WARP_CNT
* 4);
2833 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
2834 //memcpy(tpd_calmat, tpd_def_calmat_local, 8 * 4);
2835 //memcpy(tpd_def_calmat, tpd_def_calmat_local, 8 * 4);
2836 if (FACTORY_BOOT
== get_boot_mode())
2838 TPD_DEBUG("Factory mode is detected! \n");
2839 memcpy(tpd_calmat
, tpd_def_calmat_local_factory
, 8 * 4);
2840 memcpy(tpd_def_calmat
, tpd_def_calmat_local_factory
, 8 * 4);
2844 TPD_DEBUG("Normal mode is detected! \n");
2845 memcpy(tpd_calmat
, tpd_def_calmat_local_normal
, 8 * 4);
2846 memcpy(tpd_def_calmat
, tpd_def_calmat_local_normal
, 8 * 4);
2850 // set vendor string
2851 tpd
->dev
->id
.vendor
= 0x00;
2852 tpd
->dev
->id
.product
= tpd_info
.pid
;
2853 tpd
->dev
->id
.version
= tpd_info
.vid
;
2855 GTP_INFO("end %s, %d\n", __FUNCTION__
, __LINE__
);
2861 #if GTP_SLIDE_WAKEUP
2862 static s8
gtp_enter_doze(struct i2c_client
*client
)
2866 u8 i2c_control_buf
[3] = {(u8
)(GTP_REG_SLEEP
>> 8), (u8
)GTP_REG_SLEEP
, 8};
2869 #if GTP_DBL_CLK_WAKEUP
2870 i2c_control_buf
[2] = 0x09;
2873 GTP_DEBUG("entering doze mode...");
2876 i2c_control_buf
[0] = 0x80;
2877 i2c_control_buf
[1] = 0x46;
2878 ret
= gtp_i2c_write(client
, i2c_control_buf
, 3);
2881 GTP_DEBUG("failed to set doze flag into 0x8046, %d", retry
);
2884 i2c_control_buf
[0] = 0x80;
2885 i2c_control_buf
[1] = 0x40;
2886 ret
= gtp_i2c_write(client
, i2c_control_buf
, 3);
2889 doze_status
= DOZE_ENABLED
;
2890 GTP_DEBUG("GTP has been working in doze mode!");
2895 GTP_ERROR("GTP send doze cmd failed.");
2900 /*******************************************************
2902 Eter sleep function.
2908 Executive outcomes.0--success,non-0--fail.
2909 *******************************************************/
2910 static s8
gtp_enter_sleep(struct i2c_client
*client
)
2912 #if GTP_COMPATIBLE_MODE
2913 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
2915 u8 i2c_status_buf
[3] = {0x80, 0x44, 0x00};
2918 ret
= gtp_i2c_read(client
, i2c_status_buf
, 3);
2921 GTP_ERROR("[gtp_enter_sleep]Read ref status reg error.");
2924 if (i2c_status_buf
[2] & 0x80)
2927 ret
= gtp_bak_ref_proc(client
, GTP_BAK_REF_STORE
);
2930 GTP_ERROR("[gtp_enter_sleep]Store bak ref failed.");
2936 #if GTP_POWER_CTRL_SLEEP
2938 GTP_GPIO_OUTPUT(GTP_RST_PORT
, 0);
2939 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
2942 #ifdef TPD_POWER_SOURCE_1800
2943 hwPowerDown(TPD_POWER_SOURCE_1800
, "TP");
2946 #ifdef TPD_POWER_SOURCE_CUSTOM
2947 hwPowerDown(TPD_POWER_SOURCE_CUSTOM
, "TP");
2949 hwPowerDown(MT65XX_POWER_LDO_VGP2
, "TP");
2952 GTP_INFO("GTP enter sleep by poweroff!");
2959 u8 i2c_control_buf
[3] = {(u8
)(GTP_REG_SLEEP
>> 8), (u8
)GTP_REG_SLEEP
, 5};
2962 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 0);
2967 ret
= gtp_i2c_write(client
, i2c_control_buf
, 3);
2971 GTP_INFO("GTP enter sleep!");
2979 GTP_ERROR("GTP send sleep cmd failed.");
2986 /*******************************************************
2988 Wakeup from sleep mode Function.
2994 Executive outcomes.0--success,non-0--fail.
2995 *******************************************************/
2996 static s8
gtp_wakeup_sleep(struct i2c_client
*client
)
3001 GTP_DEBUG("GTP wakeup begin.");
3003 #if (GTP_POWER_CTRL_SLEEP)
3005 #if GTP_COMPATIBLE_MODE
3006 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
3008 force_reset_guitar();
3009 GTP_INFO("Esd recovery wakeup.");
3016 ret
= tpd_power_on(client
);
3020 GTP_ERROR("I2C Power on ERROR!");
3023 GTP_INFO("Ic wakeup by poweron");
3028 #if GTP_COMPATIBLE_MODE
3029 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
3031 u8 opr_buf
[2] = {0};
3033 while (retry
++ < 10)
3035 GTP_GPIO_OUTPUT(GTP_INT_PORT
, 1);
3038 ret
= gtp_i2c_test(client
);
3044 ret
= i2c_write_bytes(client
, 0x4180, opr_buf
, 1);
3047 GTP_DEBUG("Hold ss51 & dsp I2C error,retry:%d", retry
);
3053 ret
= i2c_read_bytes(client
, 0x4180, opr_buf
, 1);
3056 GTP_DEBUG("confirm ss51 & dsp hold, I2C error,retry:%d", retry
);
3059 if (0x0C != opr_buf
[0])
3061 GTP_DEBUG("ss51 & dsp not hold, val: %d, retry: %d", opr_buf
[0], retry
);
3064 GTP_DEBUG("ss51 & dsp has been hold");
3066 ret
= gtp_fw_startup(client
);
3069 GTP_ERROR("[gtp_wakeup_sleep]Startup fw failed.");
3072 GTP_INFO("flashless wakeup sleep success");
3075 force_reset_guitar();
3079 GTP_ERROR("wakeup retry timeout, process esd reset");
3080 force_reset_guitar();
3082 GTP_ERROR("GTP wakeup sleep failed.");
3086 while (retry
++ < 10)
3088 #if GTP_SLIDE_WAKEUP
3089 if (DOZE_WAKEUP
!= doze_status
)
3091 GTP_DEBUG("power wakeup, reset guitar");
3092 doze_status
= DOZE_DISABLED
;
3094 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
3095 gtp_reset_guitar(client
, 20);
3096 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
3100 GTP_DEBUG("slide(double click) wakeup, no reset guitar");
3101 doze_status
= DOZE_DISABLED
;
3103 gtp_init_ext_watchdog(client
);
3107 // if (chip_gt9xxs == 1)
3109 // gtp_reset_guitar(client, 10);
3113 // GTP_GPIO_OUTPUT(GTP_INT_PORT, 1);
3117 //GTP_GPIO_AS_INT(GTP_INT_PORT);
3118 gtp_reset_guitar(client
, 20); // for double-system, reset to default system
3123 ret
= gtp_i2c_test(client
);
3127 GTP_INFO("GTP wakeup sleep.");
3128 #if (!GTP_SLIDE_WAKEUP)
3129 if (chip_gt9xxs
== 0)
3133 gtp_init_ext_watchdog(client
);
3140 gtp_reset_guitar(client
, 20);
3143 GTP_ERROR("GTP wakeup sleep failed.");
3147 /* Function to manage low power suspend */
3148 static void tpd_suspend(struct early_suspend
*h
)
3151 u8 buf
[3] = {0x81, 0xaa, 0};
3153 #ifdef TPD_PROXIMITY
3154 if (tpd_proximity_flag
== 1)
3160 #if HOTKNOT_BLOCK_RW
3161 if(hotknot_paired_flag
)
3167 mutex_lock(&i2c_access
);
3169 gtp_i2c_read(i2c_client_point
,buf
,sizeof(buf
));
3172 mutex_unlock(&i2c_access
);
3173 GTP_INFO("GTP early suspend pair sucess");
3178 mutex_unlock(&i2c_access
);
3180 cancel_delayed_work_sync(>p_esd_check_work
);
3183 #ifdef GTP_CHARGER_DETECT
3184 cancel_delayed_work_sync(>p_charger_check_work
);
3186 mutex_lock(&i2c_access
);
3188 #if GTP_SLIDE_WAKEUP
3189 ret
= gtp_enter_doze(i2c_client_point
);
3191 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
3192 ret
= gtp_enter_sleep(i2c_client_point
);
3195 GTP_ERROR("GTP early suspend failed.");
3198 mutex_unlock(&i2c_access
);
3203 /* Function to manage power-on resume */
3204 static void tpd_resume(struct early_suspend
*h
)
3208 printk("mtk-tpd: %s start\n", __FUNCTION__
);
3209 #ifdef TPD_PROXIMITY
3211 if (tpd_proximity_flag
== 1)
3217 #if HOTKNOT_BLOCK_RW
3218 if(hotknot_paired_flag
)
3223 if(load_fw_process
== 0)
3225 ret
= gtp_wakeup_sleep(i2c_client_point
);
3229 GTP_ERROR("GTP later resume failed.");
3233 #if GTP_COMPATIBLE_MODE
3234 if (CHIP_TYPE_GT9F
== gtp_chip_type
)
3241 //gtp_send_cfg(i2c_client_point);
3244 #if GTP_CHARGER_SWITCH
3245 gtp_charger_switch(1); // force update
3248 #if GTP_SLIDE_WAKEUP
3249 doze_status
= DOZE_DISABLED
;
3251 mutex_lock(&i2c_access
);
3253 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
3254 mutex_unlock(&i2c_access
);
3258 queue_delayed_work(gtp_esd_check_workqueue
, >p_esd_check_work
, clk_tick_cnt
);
3261 #ifdef GTP_CHARGER_DETECT
3262 queue_delayed_work(gtp_charger_check_workqueue
, >p_charger_check_work
, clk_tick_cnt
);
3264 printk("mtk-tpd: %s end\n", __FUNCTION__
);
3267 static struct tpd_driver_t tpd_device_driver
=
3269 .tpd_device_name
= "gt9xx",
3270 .tpd_local_init
= tpd_local_init
,
3271 .suspend
= tpd_suspend
,
3272 .resume
= tpd_resume
,
3273 #ifdef TPD_HAVE_BUTTON
3274 .tpd_have_button
= 1,
3276 .tpd_have_button
= 0,
3280 static void tpd_off(void)
3283 #ifdef TPD_POWER_SOURCE_CUSTOM
3284 hwPowerDown(TPD_POWER_SOURCE_CUSTOM
, "TP");
3286 hwPowerDown(MT65XX_POWER_LDO_VGP2
, "TP");
3288 #ifdef TPD_POWER_SOURCE_1800
3289 hwPowerDown(TPD_POWER_SOURCE_1800
, "TP");
3291 GTP_INFO("GTP enter sleep!");
3294 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
3297 static void tpd_on(void)
3299 s32 ret
= -1, retry
= 0;
3303 ret
= tpd_power_on(i2c_client_point
);
3307 GTP_ERROR("I2C Power on ERROR!");
3310 ret
= gtp_send_cfg(i2c_client_point
);
3314 GTP_DEBUG("Wakeup sleep send config success.");
3319 GTP_ERROR("GTP later resume failed.");
3322 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
3326 /* called when loaded into kernel */
3327 static int __init
tpd_driver_init(void)
3329 GTP_INFO("MediaTek gt91xx touch panel driver init\n");
3330 #if defined(TPD_I2C_NUMBER)
3331 i2c_register_board_info(TPD_I2C_NUMBER
, &i2c_tpd
, 1);
3333 i2c_register_board_info(0, &i2c_tpd
, 1);
3335 if (tpd_driver_add(&tpd_device_driver
) < 0)
3336 GTP_INFO("add generic driver failed\n");
3341 /* should never be called */
3342 static void __exit
tpd_driver_exit(void)
3344 GTP_INFO("MediaTek gt91xx touch panel driver exit\n");
3345 tpd_driver_remove(&tpd_device_driver
);
3348 module_init(tpd_driver_init
);
3349 module_exit(tpd_driver_exit
);