Commit | Line | Data |
---|---|---|
6fa3eb70 S |
1 | #include <linux/vmalloc.h> |
2 | #include <asm/uaccess.h> | |
3 | #include <linux/major.h> | |
4 | #include <linux/miscdevice.h> | |
5 | #include <linux/i2c.h> | |
6 | #include <linux/delay.h> | |
e4c65dc7 | 7 | #include "tpd.h" |
6fa3eb70 S |
8 | |
9 | #ifdef TPD_DEBUG_CODE | |
10 | int tpd_fail_count = 0; | |
11 | int tpd_trial_count = 0; | |
12 | ||
13 | void tpd_debug_no_response(struct i2c_client *i2c_client) { | |
14 | char sleep[2] = {0x07,0x01}; | |
15 | char wakeup[2] = {0x07,0x02}; | |
16 | char threshold[2] = {0x09, 0x04}; | |
17 | char gesture[2] = {0x08, 0x11}; | |
18 | char sleeptime[2] = {0x0d, 0x01}; | |
19 | char idletime[2] = {0x0c, 0xff}; | |
20 | static int trial_index = 0; | |
21 | static int delay_index = 0; | |
22 | int trial[] = {1,9,2,8,3,7,4,6,5}; | |
23 | int delay[] = {1,100,2,50,3,25,4,12,5,6,6,1,1,500,500}; | |
24 | int trial_max = 9; | |
25 | int delay_max = 15; | |
26 | int i,j; | |
27 | ||
28 | int wakeup_count = 200; | |
29 | ||
30 | for(i=0;i<trial[trial_index];i++) { | |
31 | i2c_master_send(i2c_client, sleep, 2); | |
32 | msleep(delay[delay_index]); | |
33 | for(j=0;j<wakeup_count;j++) { | |
34 | i2c_master_send(i2c_client, wakeup, 2); | |
35 | if(i2c_master_send(i2c_client, wakeup, 2)==2) break; | |
36 | msleep(10); | |
37 | } | |
38 | if(i2c_master_send(i2c_client,gesture,2)!=2) i=wakeup_count; | |
39 | if(i2c_master_send(i2c_client,threshold,2)!=2) i=wakeup_count; | |
40 | if(i2c_master_send(i2c_client,idletime,2)!=2) i=wakeup_count; | |
41 | if(i2c_master_send(i2c_client,sleeptime,2)!=2) i=wakeup_count; | |
42 | if(i==wakeup_count) tpd_fail_count++; | |
43 | tpd_trial_count++; | |
44 | printk("trial: %d / fail: %d\n", tpd_trial_count, tpd_fail_count); | |
45 | delay_index = ((delay_index+1)%delay_max); | |
46 | } | |
47 | trial_index = ((trial_index+1)%trial_max); | |
48 | } | |
49 | ||
50 | int tpd_debug_nr = 0; | |
51 | module_param(tpd_debug_nr, int, 00644); | |
52 | module_param(tpd_fail_count, int, 00644); | |
53 | module_param(tpd_trial_count, int, 00644); | |
54 | ||
55 | int tpd_debug_time = 0; | |
56 | long tpd_last_2_int_time[2] = {0}; | |
57 | long tpd_last_down_time = 0; | |
58 | int tpd_start_profiling = 0; | |
59 | ||
60 | int tpd_down_status = 0; | |
61 | module_param(tpd_debug_time, int, 00644); | |
62 | ||
63 | void tpd_debug_set_time() { | |
64 | struct timeval t; | |
65 | ||
66 | if (!tpd_debug_time && !tpd_em_log) return; | |
67 | ||
68 | do_gettimeofday(&t); | |
69 | tpd_last_2_int_time[0] = tpd_last_2_int_time[1]; | |
70 | tpd_last_2_int_time[1] = (t.tv_sec & 0xFFF) * 1000000 + t.tv_usec; | |
71 | ||
72 | // | |
73 | // Start profiling while receive touch DOWN event | |
74 | // Stop profiling while the first frame is upadted | |
75 | // | |
76 | if (!tpd_down_status) { | |
77 | tpd_start_profiling = 1; | |
78 | tpd_last_down_time = tpd_last_2_int_time[1]; | |
79 | } | |
80 | } | |
81 | ||
82 | #ifdef TPD_DEBUG_TRACK | |
83 | int DAL_Clean(void); | |
84 | int DAL_Printf(const char *fmt, ...); | |
85 | int LCD_LayerEnable(int id, BOOL enable); | |
86 | ||
87 | int tpd_debug_track = 0; | |
88 | int tpd_debug_track_color = 0; | |
89 | int tpd_debug_touch_up = 0; | |
90 | module_param(tpd_debug_track, int, 00644); | |
91 | ||
92 | void tpd_draw(int x, int y) { | |
93 | UINT16 *buf = (UINT16 *)dal_fb_addr; | |
94 | buf = buf + (x+y*TPD_RES_X); | |
95 | tpd_debug_track_color += (tpd_debug_track_color>=31?0:1); | |
96 | *buf = (0xffe0+tpd_debug_track_color); | |
97 | } | |
98 | ||
99 | void tpd_down_debug_track(int x, int y) { | |
100 | if(tpd_debug_touch_up == 1) { | |
101 | DAL_Clean(); | |
102 | tpd_debug_touch_up = 0; | |
103 | } | |
104 | LCD_LayerEnable(5, TRUE); | |
105 | tpd_draw(x-1, y-1); tpd_draw(x, y-1); tpd_draw(x+1, y-1); | |
106 | tpd_draw(x-1, y ); tpd_draw(x+1, y ); | |
107 | tpd_draw(x-1, y+1); tpd_draw(x, y+1); tpd_draw(x+1, y+1); | |
108 | } | |
109 | ||
110 | void tpd_up_debug_track(int x, int y) { | |
111 | if(x==0 && y==0) { tpd_debug_track_color = 0; DAL_Clean(); } | |
112 | tpd_debug_touch_up = 1; | |
113 | ||
114 | } | |
115 | #endif // TPD_DEBUG_TRACK | |
116 | ||
117 | ||
118 | #define BUFFER_SIZE 128 | |
119 | ||
120 | int tpd_em_log = 0; | |
121 | module_param(tpd_em_log, int, 00664); | |
122 | ||
123 | void tpd_enable_em_log(int enable) | |
124 | { | |
125 | if(enable) { | |
126 | tpd_em_log=1; | |
127 | } else { | |
128 | tpd_em_log=0; | |
129 | } | |
130 | } | |
131 | EXPORT_SYMBOL(tpd_enable_em_log); | |
132 | ||
133 | ||
134 | int tpd_em_log_to_fs = 0; | |
135 | module_param(tpd_em_log_to_fs, int, 00664); | |
136 | ||
137 | int tpd_em_log_first = 1; | |
138 | ||
139 | struct tpd_em_log_struct | |
140 | { | |
141 | struct list_head list; | |
142 | char data[BUFFER_SIZE]; | |
143 | }; | |
144 | static LIST_HEAD(tpd_em_log_list); | |
145 | #if 0 | |
146 | ||
147 | static void *tpd_em_log_seq_start(struct seq_file *seq, loff_t *pos) | |
148 | { | |
149 | struct tpd_em_log_struct *p; | |
150 | loff_t off = 0; | |
151 | ||
152 | list_for_each_entry(p, &tpd_em_log_list, list) { | |
153 | if (*pos == off++) return p; | |
154 | } | |
155 | return NULL; | |
156 | } | |
157 | ||
158 | static void *tpd_em_log_seq_next(struct seq_file *seq, void *v, loff_t *pos) | |
159 | { | |
160 | struct list_head *n = ((struct tpd_em_log_struct *) v)->list.next; | |
161 | ||
162 | ++*pos; | |
163 | ||
164 | return (n != &tpd_em_log_list) ? list_entry(n, struct tpd_em_log_struct, list) : NULL; | |
165 | } | |
166 | ||
167 | static void tpd_em_log_seq_stop(struct seq_file *s, void *v) | |
168 | { | |
169 | struct tpd_em_log_struct *p, *p_tmp; | |
170 | list_for_each_entry_safe(p, p_tmp, &tpd_em_log_list, list) { | |
171 | list_del(&p->list); | |
172 | kfree(p); | |
173 | } | |
174 | } | |
175 | ||
176 | static int tpd_em_log_seq_show(struct seq_file *seq, void *v) | |
177 | { | |
178 | const struct tpd_em_log_struct *p = v; | |
179 | seq_printf(seq, p->data); | |
180 | return 0; | |
181 | } | |
182 | ||
183 | ||
184 | ||
185 | static struct seq_operations tpd_em_log_seq_ops = { | |
186 | .start = tpd_em_log_seq_start, | |
187 | .next = tpd_em_log_seq_next, | |
188 | .stop = tpd_em_log_seq_stop, | |
189 | .show = tpd_em_log_seq_show | |
190 | }; | |
191 | ||
192 | ||
193 | static int tpd_em_log_open(struct inode *inode, struct file *file) { | |
194 | return seq_open(file, &tpd_em_log_seq_ops); | |
195 | }; | |
196 | ||
197 | static struct file_operations tpd_em_log_file_ops = { | |
198 | .owner = THIS_MODULE, | |
199 | .open = tpd_em_log_open, | |
200 | .read = seq_read, | |
201 | .llseek = seq_lseek, | |
202 | .release = seq_release | |
203 | }; | |
204 | #endif | |
205 | int tpd_log_line_buffer = 128; // per line 128 bytes | |
206 | int tpd_log_line_cnt = 1024*10; | |
207 | module_param(tpd_log_line_buffer, int, 00664); | |
208 | module_param(tpd_log_line_cnt, int, 00664); | |
209 | ||
210 | ||
211 | struct tpd_debug_log_buf | |
212 | { | |
213 | unsigned int head; | |
214 | unsigned int tail; | |
215 | spinlock_t buffer_lock; | |
216 | unsigned int cnt; | |
217 | unsigned char *buffer; | |
218 | ||
219 | }; | |
220 | struct tpd_debug_log_buf tpd_buf; | |
221 | ||
222 | static int tpd_debug_log_open(struct inode *inode, struct file *file) | |
223 | { | |
224 | memset(&tpd_buf, 0, sizeof(struct tpd_debug_log_buf)); | |
225 | tpd_buf.buffer= vmalloc(tpd_log_line_cnt*tpd_log_line_buffer); | |
226 | if(tpd_buf.buffer == NULL) | |
227 | { | |
228 | printk("tpd_log: nomem for tpd_buf->buffer\n"); | |
229 | return -ENOMEM; | |
230 | } | |
231 | tpd_buf.head = tpd_buf.tail = 0; | |
232 | spin_lock_init(&tpd_buf.buffer_lock); | |
233 | ||
234 | file->private_data = &tpd_buf; | |
235 | printk("[tpd_em_log]: open log file\n"); | |
236 | return 0; | |
237 | } | |
238 | ||
239 | static int tpd_debug_log_release(struct inode *inode, struct file *file) | |
240 | { | |
241 | //struct tpd_debug_log_buf *tpd_buf = (tpd_debug_log_buf *)file->private_data; | |
242 | printk("[tpd_em_log]: close log file\n"); | |
243 | vfree(tpd_buf.buffer); | |
244 | //free(tpd_buf); | |
245 | return 0; | |
246 | } | |
247 | ||
248 | static ssize_t tpd_debug_log_write(struct file *file, const char __user *buffer, | |
249 | size_t count, loff_t *ppos) | |
250 | { | |
251 | return 0; | |
252 | } | |
253 | ||
254 | static ssize_t tpd_debug_log_read(struct file *file, char __user *buffer, | |
255 | size_t count, loff_t *ppos) | |
256 | { | |
257 | struct tpd_debug_log_buf *tpd_buf = (struct tpd_debug_log_buf *)file->private_data; | |
258 | unsigned int retval = 0, unit = tpd_log_line_buffer; | |
259 | unsigned char *tmp_buf = NULL; | |
260 | ||
261 | ||
262 | if (tpd_buf->head == tpd_buf->tail && | |
263 | (file->f_flags & O_NONBLOCK)) | |
264 | return -EAGAIN; | |
265 | ||
266 | ||
267 | while ((count - retval) >= unit) { | |
268 | spin_lock_irq(&tpd_buf->buffer_lock); | |
269 | if(tpd_buf->head != tpd_buf->tail) | |
270 | { | |
271 | tmp_buf = &tpd_buf->buffer[tpd_buf->tail++*unit]; | |
272 | tpd_buf->tail &= tpd_log_line_cnt - 1; | |
273 | } | |
274 | else | |
275 | { | |
276 | //printk("*******************tpd_debug_log is empty **************************************\n"); | |
277 | spin_unlock_irq(&tpd_buf->buffer_lock); | |
278 | break; | |
279 | } | |
280 | spin_unlock_irq(&tpd_buf->buffer_lock); | |
281 | //printk("%s, tmp_buf:0x%x\n", tmp_buf, tmp_buf); | |
282 | if (copy_to_user(buffer+retval, tmp_buf, unit)) | |
283 | return -EFAULT; | |
284 | ||
285 | retval += unit; | |
286 | ||
287 | } | |
288 | ||
289 | return retval; | |
290 | ||
291 | ||
292 | } | |
293 | ||
294 | static unsigned char* tpd_log_find_buffer(void) | |
295 | { | |
296 | unsigned char *buffer = NULL; | |
297 | unsigned unit = tpd_log_line_buffer; | |
298 | if(tpd_buf.buffer == NULL) | |
299 | { | |
300 | printk( "[tpd_em_log] :tpd_buf.buffer is NULL \n"); | |
301 | return NULL; | |
302 | } | |
303 | spin_lock(&tpd_buf.buffer_lock); | |
304 | buffer = &tpd_buf.buffer[tpd_buf.head++*unit]; | |
305 | tpd_buf.head &= tpd_log_line_cnt - 1; | |
306 | spin_unlock(&tpd_buf.buffer_lock); | |
307 | if(tpd_buf.head == tpd_buf.tail) | |
308 | { | |
309 | snprintf(buffer, unit, "[tpd_em_log] overlay !!!!!\n"); | |
310 | return NULL; | |
311 | } | |
312 | memset(buffer, 0, unit); | |
313 | return buffer; | |
314 | } | |
315 | ||
316 | static struct file_operations tpd_debug_log_fops = { | |
317 | .owner = THIS_MODULE, | |
318 | .read = tpd_debug_log_read, | |
319 | .write = tpd_debug_log_write, | |
320 | .open = tpd_debug_log_open, | |
321 | .release = tpd_debug_log_release, | |
322 | }; | |
323 | ||
324 | static struct miscdevice tpd_debug_log_dev = { | |
325 | .minor = MISC_DYNAMIC_MINOR, | |
326 | .name = "tpd_em_log", | |
327 | .fops = &tpd_debug_log_fops, | |
328 | }; | |
329 | void tpd_em_log_output(int raw_x, int raw_y, int cal_x, int cal_y, int p, int down) { | |
330 | if (down == TPD_TYPE_INT_DOWN) { | |
331 | printk("[tpd_em_log] int trigger down\n"); | |
332 | } else if (down == TPD_TYPE_INT_UP) { | |
333 | printk("[tpd_em_log] int trigger up\n"); | |
334 | } else if (down == TPD_TYPE_TIMER) { | |
335 | printk("[tpd_em_log] timer trigger\n"); | |
336 | } else if (down == TPD_TYPE_RAW_DATA) { | |
337 | if (tpd_em_log == TPD_TYPE_RAW_DATA) { | |
338 | printk("[tpd_em_log] rx=%d,ry=%d,rz1=%d,rz2=%d,p=%d,r\n", | |
339 | raw_x, raw_y, cal_x, cal_y, p); | |
340 | } | |
341 | } else if(down == TPD_TYPE_REJECT1){ | |
342 | printk("[tpd_em_log] the first or last point is rejected\n"); | |
343 | }else if(down == TPD_TYPE_REJECT2){ | |
344 | printk("[tpd_em_log] pressure(%d) > NICE_PRESSURE(%d), debounce debt0:%d ms, debt1:%d ms, spl_num:%d\n", raw_x, raw_y, cal_x, cal_y, p); | |
345 | } else if(down == TPD_TYPE_FIST_LATENCY) { | |
346 | printk("[tpd_em_log] The first touch latency is %d ms\n", raw_x/1000); | |
347 | } else if (down && tpd_down_status == 0) { | |
348 | printk("[tpd_em_log] rx=%d,ry=%d,cx=%d,cy=%d,p=%d,d(+%ld ms)\n", | |
349 | raw_x, raw_y, cal_x, cal_y, p, (tpd_last_2_int_time[1] - tpd_last_2_int_time[0]) / 1000); | |
350 | } else if (down && tpd_down_status != 0) { | |
351 | printk("[tpd_em_log] rx=%d,ry=%d,cx=%d,cy=%d,p=%d,m(+%ld ms)\n", | |
352 | raw_x, raw_y, cal_x, cal_y, p, (tpd_last_2_int_time[1] - tpd_last_2_int_time[0]) / 1000); | |
353 | } else { | |
354 | printk("[tpd_em_log] rx=%d,ry=%d,cx=%d,cy=%d,p=%d,u(+%ld ms)\n", | |
355 | raw_x, raw_y, cal_x, cal_y, p, (tpd_last_2_int_time[1] - tpd_last_2_int_time[0]) / 1000); | |
356 | } | |
357 | } | |
358 | ||
359 | void tpd_em_log_store(int raw_x, int raw_y, int cal_x, int cal_y, int p, int down) { | |
360 | //static struct proc_dir_entry *entry = NULL; | |
361 | //struct tpd_em_log_struct *tpd_em_log_struct_new; | |
362 | struct timeval t; | |
363 | ||
364 | #if 0 | |
365 | if (tpd_em_log_first) { | |
366 | entry = create_proc_entry("tpd_em_log", 0, NULL); | |
367 | if (entry) { | |
368 | entry->proc_fops = &tpd_em_log_file_ops; | |
369 | } | |
370 | tpd_em_log_first = 0; | |
371 | return; | |
372 | } | |
373 | tpd_em_log_struct_new = kmalloc(sizeof(struct tpd_em_log_struct), GFP_ATOMIC); | |
374 | ||
375 | memset(tpd_em_log_struct_new, 0, sizeof(struct tpd_em_log_struct)); | |
376 | #else | |
377 | unsigned char *buffer = NULL; | |
378 | //unsigned int unit = tpd_log_line_buffer; | |
379 | ||
380 | //printk("[tpd_em_log]: start register log file"); | |
381 | ||
382 | #endif | |
383 | buffer = tpd_log_find_buffer(); | |
384 | if(buffer == NULL) | |
385 | { | |
386 | printk("not buffer \n"); | |
387 | return; | |
388 | } | |
389 | do_gettimeofday(&t); | |
390 | ||
391 | if (down == TPD_TYPE_INT_DOWN) { | |
392 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] int trigger down\n", (t.tv_sec & 0xFFF), t.tv_usec); | |
393 | } else if (down == TPD_TYPE_INT_UP) { | |
394 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] int trigger up\n", (t.tv_sec & 0xFFF), t.tv_usec); | |
395 | } else if (down == TPD_TYPE_TIMER) { | |
396 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] timer trigger\n", (t.tv_sec & 0xFFF), t.tv_usec); | |
397 | } else if (down == TPD_TYPE_RAW_DATA) { | |
398 | if (tpd_em_log == TPD_TYPE_RAW_DATA) { | |
399 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] rx=%d,ry=%d,rz1=%d,rz2=%d,p=%d,r\n", | |
400 | (t.tv_sec & 0xFFF), t.tv_usec, raw_x, raw_y, cal_x, cal_y, p); | |
401 | } | |
402 | } else if(down == TPD_TYPE_REJECT1){ | |
403 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] the first or last point is rejected\n", (t.tv_sec & 0xFFF), t.tv_usec); | |
404 | }else if(down == TPD_TYPE_REJECT2){ | |
405 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] pressure(%d) > NICE_PRESSURE(%d), debounce debt0:%d, debt1:%d, spl_num:%d\n", | |
406 | (t.tv_sec & 0xFFF), t.tv_usec, raw_x, raw_y, cal_x, cal_y, p); | |
407 | } else if(down == TPD_TYPE_FIST_LATENCY) { | |
408 | snprintf(buffer, tpd_log_line_buffer,"[%5lu.%06lu][tpd_em_log] The first touch latency is %d ms\n", (t.tv_sec & 0xFFF), t.tv_usec, raw_x/1000); | |
409 | } else if (down && tpd_down_status == 0) { | |
410 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] rx=%d,ry=%d,cx=%d,cy=%d,p=%d,d(+%ld ms)\n", | |
411 | (t.tv_sec & 0xFFF), t.tv_usec, raw_x, raw_y, cal_x, cal_y, p, (tpd_last_2_int_time[1] - tpd_last_2_int_time[0]) / 1000); | |
412 | } else if (down && tpd_down_status != 0) { | |
413 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] rx=%d,ry=%d,cx=%d,cy=%d,p=%d,d(+%ld ms)\n", | |
414 | (t.tv_sec & 0xFFF), t.tv_usec, raw_x, raw_y, cal_x, cal_y, p, (tpd_last_2_int_time[1] - tpd_last_2_int_time[0]) / 1000); | |
415 | } else { | |
416 | snprintf(buffer, tpd_log_line_buffer, "[%5lu.%06lu][tpd_em_log] rx=%d,ry=%d,cx=%d,cy=%d,p=%d,u(+%ld ms)\n", | |
417 | (t.tv_sec & 0xFFF), t.tv_usec, raw_x, raw_y, cal_x, cal_y, p, (tpd_last_2_int_time[1] - tpd_last_2_int_time[0]) / 1000); | |
418 | } | |
419 | ||
420 | //list_add_tail(&tpd_em_log_struct_new->list, &tpd_em_log_list); | |
421 | } | |
422 | ||
423 | void tpd_em_log_release(void) { | |
424 | struct tpd_em_log_struct *p, *p_tmp; | |
425 | if (!tpd_em_log_first) { | |
426 | remove_proc_entry("tpd_em_log", NULL); | |
427 | ||
428 | list_for_each_entry_safe(p, p_tmp, &tpd_em_log_list, list) { | |
429 | list_del(&p->list); | |
430 | kfree(p); | |
431 | } | |
432 | ||
433 | tpd_em_log_first = 1; | |
434 | tpd_em_log_to_fs = 0; | |
435 | } | |
436 | } | |
437 | ||
438 | static int __init tpd_log_init(void) | |
439 | { | |
440 | if (misc_register(&tpd_debug_log_dev) < 0) | |
441 | { | |
442 | printk( "[tpd_em_log] :register device failed \n"); | |
443 | return -1; | |
444 | } | |
445 | printk( "[tpd_em_log] :register device successfully \n"); | |
446 | return 0; | |
447 | } | |
448 | ||
449 | int tpd_debuglog = 0; | |
450 | module_param(tpd_debuglog, int, 00664); | |
451 | ||
452 | module_init(tpd_log_init); | |
453 | #endif // TPD_DEBUG_CODE |