1 /*
2 *
3 * FocalTech TouchScreen driver.
4 *
5 * Copyright (c) 2012-2018, FocalTech Systems, Ltd., all rights reserved.
6 *
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18 /************************************************************************
19 *
20 * File Name: focaltech_test.c
21 *
22 * Author: Focaltech Driver Team
23 *
24 * Created: 2016-08-01
25 *
26 * Modify:
27 *
28 * Abstract: create char device and proc node for the comm between APK and TP
29 *
30 ************************************************************************/
31
32 /*****************************************************************************
33 * Included header files
34 *****************************************************************************/
35 #include "focaltech_test.h"
36
37 /*****************************************************************************
38 * Private constant and macro definitions using #define
39 *****************************************************************************/
40
41 /*****************************************************************************
42 * Global variable or extern global variabls/functions
43 *****************************************************************************/
44 struct fts_test *fts_ftest;
45
46 struct test_funcs *test_func_list[] = {
47 &test_func_ft8201,
48 };
49
50 /*****************************************************************************
51 * Static function prototypes
52 *****************************************************************************/
53
54 /*****************************************************************************
55 * functions body
56 *****************************************************************************/
sys_delay(int ms)57 void sys_delay(int ms)
58 {
59 msleep(ms);
60 }
61
focal_abs(int value)62 int focal_abs(int value)
63 {
64 if (value < 0)
65 value = 0 - value;
66
67 return value;
68 }
69
fts_malloc(size_t size)70 void *fts_malloc(size_t size)
71 {
72 return kzalloc(size, GFP_KERNEL);
73 }
74
fts_free_proc(void * p)75 void fts_free_proc(void *p)
76 {
77 return kfree(p);
78 }
79
print_buffer(int * buffer,int length,int line_num)80 void print_buffer(int *buffer, int length, int line_num)
81 {
82 int i = 0;
83
84 if (NULL == buffer) {
85 FTS_TEST_DBG("buffer is null");
86 return;
87 }
88
89 for (i = 0; i < length; i++) {
90 printk("%5d ", buffer[i]);
91 if ((0 == (i + 1) % line_num))
92 printk("\n");
93 }
94 printk("\n");
95 }
96
97 /********************************************************************
98 * test i2c read/write interface
99 *******************************************************************/
fts_test_i2c_read(u8 * writebuf,int writelen,u8 * readbuf,int readlen)100 static int fts_test_i2c_read(u8 *writebuf, int writelen, u8 *readbuf, int readlen)
101 {
102 int ret = 0;
103 #if 1
104 if (NULL == fts_data) {
105 FTS_TEST_ERROR("fts_data is null, no test");
106 return -EINVAL;
107 }
108 ret = fts_i2c_read(fts_data->client, writebuf, writelen, readbuf, readlen);
109 #else
110 ret = fts_i2c_read(writebuf, writelen, readbuf, readlen);
111 #endif
112
113 if (ret < 0)
114 return ret;
115 else
116 return 0;
117 }
118
fts_test_i2c_write(u8 * writebuf,int writelen)119 static int fts_test_i2c_write(u8 *writebuf, int writelen)
120 {
121 int ret = 0;
122 #if 1
123 if (NULL == fts_data) {
124 FTS_TEST_ERROR("fts_data is null, no test");
125 return -EINVAL;
126 }
127 ret = fts_i2c_write(fts_data->client, writebuf, writelen);
128 #else
129 ret = fts_i2c_write(writebuf, writelen);
130 #endif
131
132 if (ret < 0)
133 return ret;
134 else
135 return 0;
136 }
137
fts_test_read_reg(u8 addr,u8 * val)138 int fts_test_read_reg(u8 addr, u8 *val)
139 {
140 return fts_test_i2c_read(&addr, 1, val, 1);
141 }
142
fts_test_write_reg(u8 addr,u8 val)143 int fts_test_write_reg(u8 addr, u8 val)
144 {
145 int ret;
146 u8 cmd[2] = {0};
147
148 cmd[0] = addr;
149 cmd[1] = val;
150 ret = fts_test_i2c_write(cmd, 2);
151
152 return ret;
153 }
154
fts_test_read(u8 addr,u8 * readbuf,int readlen)155 int fts_test_read(u8 addr, u8 *readbuf, int readlen)
156 {
157 int ret = 0;
158 int i = 0;
159 int packet_length = 0;
160 int packet_num = 0;
161 int packet_remainder = 0;
162 int offset = 0;
163 int byte_num = readlen;
164
165 packet_num = byte_num / BYTES_PER_TIME;
166 packet_remainder = byte_num % BYTES_PER_TIME;
167 if (packet_remainder)
168 packet_num++;
169
170 if (byte_num < BYTES_PER_TIME) {
171 packet_length = byte_num;
172 } else {
173 packet_length = BYTES_PER_TIME;
174 }
175 // FTS_TEST_DBG("packet num:%d, remainder:%d", packet_num, packet_remainder);
176
177 ret = fts_test_i2c_read(&addr, 1, &readbuf[offset], packet_length);
178 if (ret < 0) {
179 FTS_TEST_ERROR("read buffer fail");
180 return ret;
181 }
182 for (i = 1; i < packet_num; i++) {
183 offset += packet_length;
184 if ((i == (packet_num - 1)) && packet_remainder) {
185 packet_length = packet_remainder;
186 }
187
188 ret = fts_test_i2c_read(NULL, 0, &readbuf[offset], packet_length);
189 if (ret < 0) {
190 FTS_TEST_ERROR("read buffer fail");
191 return ret;
192 }
193 }
194
195 return 0;
196 }
197
fts_test_write(u8 addr,u8 * writebuf,int writelen)198 int fts_test_write(u8 addr, u8 *writebuf, int writelen)
199 {
200 int ret = 0;
201 int i = 0;
202 u8 data[BYTES_PER_TIME + 1] = { 0 };
203 int packet_length = 0;
204 int packet_num = 0;
205 int packet_remainder = 0;
206 int offset = 0;
207 int byte_num = writelen;
208
209 packet_num = byte_num / BYTES_PER_TIME;
210 packet_remainder = byte_num % BYTES_PER_TIME;
211 if (packet_remainder)
212 packet_num++;
213
214 if (byte_num < BYTES_PER_TIME) {
215 packet_length = byte_num;
216 } else {
217 packet_length = BYTES_PER_TIME;
218 }
219 FTS_TEST_DBG("packet num:%d, remainder:%d", packet_num, packet_remainder);
220
221 data[0] = addr;
222 for (i = 0; i < packet_num; i++) {
223 if (i != 0) {
224 data[0] = addr + 1;
225 }
226 if ((i == (packet_num - 1)) && packet_remainder) {
227 packet_length = packet_remainder;
228 }
229 memcpy(&data[1], &writebuf[offset], packet_length);
230
231 ret = fts_test_i2c_write(data, packet_length + 1);
232 if (ret < 0) {
233 FTS_TEST_ERROR("write buffer fail");
234 return ret;
235 }
236
237 offset += packet_length;
238 }
239
240 return 0;
241 }
242
243 /********************************************************************
244 * test global function enter work/factory mode
245 *******************************************************************/
enter_work_mode(void)246 int enter_work_mode(void)
247 {
248 int ret = 0;
249 u8 mode = 0;
250 int i = 0;
251 int j = 0;
252
253 FTS_TEST_FUNC_ENTER();
254
255 ret = fts_test_read_reg(DEVIDE_MODE_ADDR, &mode);
256 if ((ret >= 0) && (0x00 == mode))
257 return 0;
258
259 for (i = 0; i < ENTER_WORK_FACTORY_RETRIES; i++) {
260 ret = fts_test_write_reg(DEVIDE_MODE_ADDR, 0x00);
261 if (ret >= 0) {
262 sys_delay(FACTORY_TEST_DELAY);
263 for (j = 0; j < 20; j++) {
264 ret = fts_test_read_reg(DEVIDE_MODE_ADDR, &mode);
265 if ((ret >= 0) && (0x00 == mode)) {
266 FTS_TEST_INFO("enter work mode success");
267 return 0;
268 } else
269 sys_delay(FACTORY_TEST_DELAY);
270 }
271 }
272
273 sys_delay(50);
274 }
275
276 if (i >= ENTER_WORK_FACTORY_RETRIES) {
277 FTS_TEST_ERROR("Enter work mode fail");
278 return -EIO;
279 }
280
281 FTS_TEST_FUNC_EXIT();
282 return 0;
283 }
284
enter_factory_mode(void)285 int enter_factory_mode(void)
286 {
287 int ret = 0;
288 u8 mode = 0;
289 int i = 0;
290 int j = 0;
291
292 ret = fts_test_read_reg(DEVIDE_MODE_ADDR, &mode);
293 if ((ret >= 0) && (0x40 == mode))
294 return 0;
295
296 for (i = 0; i < ENTER_WORK_FACTORY_RETRIES; i++) {
297 ret = fts_test_write_reg(DEVIDE_MODE_ADDR, 0x40);
298 if (ret >= 0) {
299 sys_delay(FACTORY_TEST_DELAY);
300 for (j = 0; j < 20; j++) {
301 ret = fts_test_read_reg(DEVIDE_MODE_ADDR, &mode);
302 if ((ret >= 0) && (0x40 == mode)) {
303 FTS_TEST_INFO("enter factory mode success");
304 sys_delay(200);
305 return 0;
306 } else
307 sys_delay(FACTORY_TEST_DELAY);
308 }
309 }
310
311 sys_delay(50);
312 }
313
314 if (i >= ENTER_WORK_FACTORY_RETRIES) {
315 FTS_TEST_ERROR("Enter factory mode fail");
316 return -EIO;
317 }
318
319 return 0;
320 }
321
322 /*
323 * read_mass_data - read rawdata/short test data
324 * addr - register addr which read data from
325 * byte_num - read data length, unit:byte
326 * buf - save data
327 *
328 * return 0 if read data succuss, otherwise return error code
329 */
read_mass_data(u8 addr,int byte_num,int * buf)330 int read_mass_data(u8 addr, int byte_num, int *buf)
331 {
332 int ret = 0;
333 int i = 0;
334 u8 *data = NULL;
335
336 data = (u8 *)fts_malloc(byte_num * sizeof(u8));
337 if (NULL == data) {
338 FTS_TEST_SAVE_ERR("mass data buffer malloc fail\n");
339 return -ENOMEM;
340 }
341
342 /* read rawdata buffer */
343 FTS_TEST_INFO("mass data len:%d", byte_num);
344 ret = fts_test_read(addr, data, byte_num);
345 if (ret < 0) {
346 FTS_TEST_SAVE_ERR("read mass data fail\n");
347 goto read_massdata_err;
348 }
349
350 for (i = 0; i < byte_num; i = i + 2) {
351 buf[i >> 1] = (int)(((int)(data[i]) << 8) + data[i + 1]);
352 }
353
354 ret = 0;
355 read_massdata_err:
356 fts_free(data);
357 return ret;
358 }
359
short_get_adcdata_incell(u8 retval,u8 ch_num,int byte_num,int * adc_buf)360 int short_get_adcdata_incell(u8 retval, u8 ch_num, int byte_num, int *adc_buf)
361 {
362 int ret = 0;
363 int times = 0;
364 u8 short_state = 0;
365
366 FTS_TEST_FUNC_ENTER();
367
368 /* Start ADC sample */
369 ret = fts_test_write_reg(FACTORY_REG_SHORT_TEST_EN, 0x01);
370 if (ret) {
371 FTS_TEST_SAVE_ERR("start short test fail\n");
372 goto adc_err;
373 }
374
375 sys_delay(ch_num * FACTORY_TEST_DELAY);
376 for (times = 0; times < FACTORY_TEST_RETRY; times++) {
377 ret = fts_test_read_reg(FACTORY_REG_SHORT_TEST_STATE, &short_state);
378 if ((ret >= 0) && (retval == short_state))
379 break;
380 else
381 FTS_TEST_DBG("reg%x=%x,retry:%d",
382 FACTORY_REG_SHORT_TEST_STATE, short_state, times);
383
384 sys_delay(FACTORY_TEST_RETRY_DELAY);
385 }
386 if (times >= FACTORY_TEST_RETRY) {
387 FTS_TEST_SAVE_ERR("short test timeout, ADC data not OK\n");
388 ret = -EIO;
389 goto adc_err;
390 }
391
392 ret = read_mass_data(FACTORY_REG_SHORT_ADDR, byte_num, adc_buf);
393 if (ret) {
394 FTS_TEST_SAVE_ERR("get short(adc) data fail\n");
395 }
396
397 adc_err:
398 FTS_TEST_FUNC_EXIT();
399 return ret;
400 }
401
402 /*
403 * wait_state_update - wait fw status update
404 */
wait_state_update(u8 retval)405 int wait_state_update(u8 retval)
406 {
407 int ret = 0;
408 int times = 0;
409 u8 state = 0xFF;
410
411 while (times++ < FACTORY_TEST_RETRY) {
412 sys_delay(FACTORY_TEST_DELAY);
413 /* Wait register status update */
414 state = 0xFF;
415 ret = fts_test_read_reg(FACTORY_REG_PARAM_UPDATE_STATE, &state);
416 if ((ret >= 0) && (retval == state))
417 break;
418 else
419 FTS_TEST_DBG("reg%x=%x,retry:%d", \
420 FACTORY_REG_PARAM_UPDATE_STATE, state, times);
421 }
422
423 if (times >= FACTORY_TEST_RETRY) {
424 FTS_TEST_SAVE_ERR("Wait State Update fail\n");
425 return -EIO;
426 }
427
428 return 0;
429 }
430
431 /*
432 * start_scan - start to scan a frame
433 */
start_scan(void)434 int start_scan(void)
435 {
436 int ret = 0;
437 u8 addr = 0;
438 u8 val = 0;
439 u8 finish_val = 0;
440 int times = 0;
441 struct fts_test *tdata = fts_ftest;
442
443 if ((NULL == tdata) || (NULL == tdata->func) ) {
444 FTS_TEST_ERROR("test/func is null\n");
445 return -EINVAL;
446 }
447
448 if (SCAN_SC == tdata->func->startscan_mode) {
449 /* sc ic */
450 addr = FACTORY_REG_SCAN_ADDR2;
451 val = 0x01;
452 finish_val = 0x00;
453 } else {
454 addr = DEVIDE_MODE_ADDR;
455 val = 0xC0;
456 finish_val = 0x40;
457 }
458
459 /* write register to start scan */
460 ret = fts_test_write_reg(addr, val);
461 if (ret < 0) {
462 FTS_TEST_SAVE_ERR("write start scan mode fail\n");
463 return ret;
464 }
465
466 /* Wait for the scan to complete */
467 while (times++ < FACTORY_TEST_RETRY) {
468 sys_delay(FACTORY_TEST_DELAY);
469
470 ret = fts_test_read_reg(addr, &val);
471 if ((ret >= 0) && (val == finish_val)) {
472 break;
473 } else
474 FTS_TEST_DBG("reg%x=%x,retry:%d", addr, val, times);
475 }
476
477 if (times >= FACTORY_TEST_RETRY) {
478 FTS_TEST_SAVE_ERR("scan timeout\n");
479 return -EIO;
480 }
481
482 return 0;
483 }
484
read_rawdata(u8 off_addr,u8 off_val,u8 rawdata_addr,int byte_num,int * data)485 static int read_rawdata(
486 u8 off_addr,
487 u8 off_val,
488 u8 rawdata_addr,
489 int byte_num,
490 int *data)
491 {
492 int ret = 0;
493
494 /* set line addr or rawdata start addr */
495 ret = fts_test_write_reg(off_addr, off_val);
496 if (ret < 0) {
497 FTS_TEST_SAVE_ERR("wirte line/start addr fail\n");
498 return ret;
499 }
500
501 ret = read_mass_data(rawdata_addr, byte_num, data);
502 if (ret < 0) {
503 FTS_TEST_SAVE_ERR("read rawdata fail\n");
504 return ret;
505 }
506
507 return 0;
508 }
509
get_rawdata(int * data)510 int get_rawdata(int *data)
511 {
512 int ret = 0;
513 u8 val = 0;
514 u8 addr = 0;
515 u8 rawdata_addr = 0;
516 int byte_num = 0;
517 struct fts_test *tdata = fts_ftest;
518
519 if ((NULL == tdata) || (NULL == tdata->func) ) {
520 FTS_TEST_ERROR("test/func is null\n");
521 return -EINVAL;
522 }
523
524 /* enter factory mode */
525 ret = enter_factory_mode();
526 if (ret < 0) {
527 FTS_TEST_SAVE_ERR("failed to enter factory mode,ret=%d\n", ret);
528 return ret;
529 }
530
531 /* start scanning */
532 ret = start_scan();
533 if (ret < 0) {
534 FTS_TEST_SAVE_ERR("scan fail\n");
535 return ret;
536 }
537
538 /* read rawdata */
539 if (IC_HW_INCELL == tdata->func->hwtype) {
540 val = 0xAD;
541 addr = FACTORY_REG_LINE_ADDR;
542 rawdata_addr = FACTORY_REG_RAWDATA_ADDR;
543 } else if (IC_HW_MC_SC == tdata->func->hwtype) {
544 val = 0xAA;
545 addr = FACTORY_REG_LINE_ADDR;
546 rawdata_addr = FACTORY_REG_RAWDATA_ADDR_MC_SC;
547 } else {
548 val = 0x0;
549 addr = FACTORY_REG_RAWDATA_SADDR_SC;
550 rawdata_addr = FACTORY_REG_RAWDATA_ADDR_SC;
551 }
552
553 byte_num = tdata->node.node_num * 2;
554 ret = read_rawdata(addr, val, rawdata_addr, byte_num, data);
555 if (ret < 0) {
556 FTS_TEST_SAVE_ERR("read rawdata fail\n");
557 return ret;
558 }
559
560 return 0;
561 }
562
563 /*
564 * chip_clb - auto clb
565 */
chip_clb(void)566 int chip_clb(void)
567 {
568 int ret = 0;
569 u8 val = 0;
570 int times = 0;
571
572 /* start clb */
573 ret = fts_test_write_reg(FACTORY_REG_CLB, 0x04);
574 if (ret) {
575 FTS_TEST_SAVE_ERR("write start clb fail\n");
576 return ret;
577 }
578
579 while (times++ < FACTORY_TEST_RETRY) {
580 sys_delay(FACTORY_TEST_RETRY_DELAY);
581 ret = fts_test_read_reg(FACTORY_REG_CLB, &val);
582 if ((0 == ret) && (0x02 == val)) {
583 /* clb ok */
584 break;
585 } else
586 FTS_TEST_DBG("reg%x=%x,retry:%d", FACTORY_REG_CLB, val, times);
587 }
588
589 if (times >= FACTORY_TEST_RETRY) {
590 FTS_TEST_SAVE_ERR("chip clb timeout\n");
591 return -EIO;
592 }
593
594 return 0;
595 }
596
597 /*
598 * get_cb_incell - get cb data for incell IC
599 */
get_cb_incell(u16 saddr,int byte_num,int * cb_buf)600 int get_cb_incell(u16 saddr, int byte_num, int *cb_buf)
601 {
602 int ret = 0;
603 int i = 0;
604 u8 cb_addr = 0;
605 u8 addr_h = 0;
606 u8 addr_l = 0;
607 int read_num = 0;
608 int packet_num = 0;
609 int packet_remainder = 0;
610 int offset = 0;
611 int addr = 0;
612 u8 *data = NULL;
613
614 data = (u8 *)fts_malloc(byte_num * sizeof(u8));
615 if (NULL == data) {
616 FTS_TEST_SAVE_ERR("cb buffer malloc fail\n");
617 return -ENOMEM;
618 }
619
620 packet_num = byte_num / BYTES_PER_TIME;
621 packet_remainder = byte_num % BYTES_PER_TIME;
622 if (packet_remainder)
623 packet_num++;
624 read_num = BYTES_PER_TIME;
625
626 FTS_TEST_INFO("cb packet:%d,remainder:%d", packet_num, packet_remainder);
627 cb_addr = FACTORY_REG_CB_ADDR;
628 for (i = 0; i < packet_num; i++) {
629 offset = read_num * i;
630 addr = saddr + offset;
631 addr_h = (addr >> 8) & 0xFF;
632 addr_l = addr & 0xFF;
633 if ((i == (packet_num - 1)) && packet_remainder) {
634 read_num = packet_remainder;
635 }
636
637 ret = fts_test_write_reg(FACTORY_REG_CB_ADDR_H, addr_h);
638 if (ret) {
639 FTS_TEST_SAVE_ERR("write cb addr high fail\n");
640 goto TEST_CB_ERR;
641 }
642 ret = fts_test_write_reg(FACTORY_REG_CB_ADDR_L, addr_l);
643 if (ret) {
644 FTS_TEST_SAVE_ERR("write cb addr low fail\n");
645 goto TEST_CB_ERR;
646 }
647
648 ret = fts_test_read(cb_addr, data + offset, read_num);
649 if (ret) {
650 FTS_TEST_SAVE_ERR("read cb fail\n");
651 goto TEST_CB_ERR;
652 }
653 }
654
655 for (i = 0; i < byte_num; i++) {
656 cb_buf[i] = data[i];
657 }
658
659 TEST_CB_ERR:
660 fts_free(data);
661 return ret;
662 }
663
get_cb_sc(int byte_num,int * cb_buf,enum byte_mode mode)664 int get_cb_sc(int byte_num, int *cb_buf, enum byte_mode mode)
665 {
666 int ret = 0;
667 int i = 0;
668 int read_num = 0;
669 int packet_num = 0;
670 int packet_remainder = 0;
671 int offset = 0;
672 u8 cb_addr = 0;
673 u8 off_addr = 0;
674 struct fts_test *tdata = fts_ftest;
675 u8 *cb = NULL;
676
677 if ((NULL == tdata) || (NULL == tdata->func) ) {
678 FTS_TEST_ERROR("test/func is null\n");
679 return -EINVAL;
680 }
681
682 cb = (u8 *)fts_malloc(byte_num * sizeof(u8));
683 if (NULL == cb) {
684 FTS_TEST_SAVE_ERR("malloc memory for cb buffer fail\n");
685 return -ENOMEM;
686 }
687
688 if (IC_HW_MC_SC == tdata->func->hwtype) {
689 cb_addr = FACTORY_REG_MC_SC_CB_ADDR;
690 off_addr = FACTORY_REG_MC_SC_CB_ADDR_OFF;
691 } else if (IC_HW_SC == tdata->func->hwtype) {
692 cb_addr = FACTORY_REG_SC_CB_ADDR;
693 off_addr = FACTORY_REG_SC_CB_ADDR_OFF;
694 }
695
696 packet_num = byte_num / BYTES_PER_TIME;
697 packet_remainder = byte_num % BYTES_PER_TIME;
698 if (packet_remainder)
699 packet_num++;
700 read_num = BYTES_PER_TIME;
701 offset = 0;
702
703 FTS_TEST_INFO("cb packet:%d,remainder:%d", packet_num, packet_remainder);
704 for (i = 0; i < packet_num; i++) {
705 if ((i == (packet_num - 1)) && packet_remainder) {
706 read_num = packet_remainder;
707 }
708
709 ret = fts_test_write_reg(off_addr, offset);
710 if (ret < 0) {
711 FTS_TEST_SAVE_ERR("write cb addr offset fail\n");
712 goto cb_err;
713 }
714
715 ret = fts_test_read(cb_addr, cb + offset, read_num);
716 if (ret < 0) {
717 FTS_TEST_SAVE_ERR("read cb fail\n");
718 goto cb_err;
719 }
720
721 offset += read_num;
722 }
723
724 if (DATA_ONE_BYTE == mode) {
725 for (i = 0; i < byte_num; i++) {
726 cb_buf[i] = cb[i];
727 }
728 } else if (DATA_TWO_BYTE == mode) {
729 for (i = 0; i < byte_num; i = i + 2) {
730 cb_buf[i >> 1] = (int)(((int)(cb[i]) << 8) + cb[i + 1]);
731 }
732 }
733
734 ret = 0;
735 cb_err:
736 fts_free(cb);
737 return ret;
738 }
739
compare_data(int * data,int min,int max,int min_vk,int max_vk,bool key)740 bool compare_data(int *data, int min, int max, int min_vk, int max_vk, bool key)
741 {
742 int i = 0;
743 bool result = true;
744 struct fts_test *tdata = fts_ftest;
745 int rx = tdata->node.rx_num;
746 int node_va = tdata->node.node_num - tdata->node.key_num;
747
748 if (!data || !tdata->node_valid) {
749 FTS_TEST_SAVE_ERR("data/node_valid is null\n");
750 return false;
751 }
752
753 for (i = 0; i < node_va; i++) {
754 if (0 == tdata->node_valid[i])
755 continue;
756
757 if ((data[i] < min) || (data[i] > max)) {
758 FTS_TEST_SAVE_ERR("test fail,node(%4d,%4d)=%5d,range=(%5d,%5d)\n",
759 i / rx + 1, i % rx + 1, data[i], min, max);
760 result = false;
761 }
762 }
763
764 if (key) {
765 for (i = node_va; i < tdata->node.node_num; i++) {
766 if (0 == tdata->node_valid[i])
767 continue;
768
769 if ((data[i] < min_vk) || (data[i] > max_vk)) {
770 FTS_TEST_SAVE_ERR("test fail,node(%4d,%4d)=%5d,range=(%5d,%5d)\n",
771 i / rx + 1, i % rx + 1,
772 data[i], min_vk, max_vk);
773 result = false;
774 }
775 }
776 }
777
778 return result;
779 }
780
compare_array(int * data,int * min,int * max,bool key)781 bool compare_array(int *data, int *min, int *max, bool key)
782 {
783 int i = 0;
784 bool result = true;
785 struct fts_test *tdata = fts_ftest;
786 int rx = tdata->node.rx_num;
787 int node_num = tdata->node.node_num;
788
789 if (!data || !min || !max || !tdata->node_valid) {
790 FTS_TEST_SAVE_ERR("data/min/max/node_valid is null\n");
791 return false;
792 }
793
794 if (!key) {
795 node_num -= tdata->node.key_num;
796 }
797 for (i = 0; i < node_num; i++) {
798 if (0 == tdata->node_valid[i])
799 continue;
800
801 if ((data[i] < min[i]) || (data[i] > max[i])) {
802 FTS_TEST_SAVE_ERR("test fail,node(%4d,%4d)=%5d,range=(%5d,%5d)\n",
803 i / rx + 1, i % rx + 1, data[i], min[i], max[i]);
804 result = false;
805 }
806 }
807
808 return result;
809 }
810
811 /*
812 * show_data - show and save test data to testresult.txt
813 */
show_data(int * data,bool key)814 void show_data(int *data, bool key)
815 {
816 int i = 0;
817 int j = 0;
818 struct fts_test *tdata = fts_ftest;
819 int node_num = tdata->node.node_num;
820 int tx_num = tdata->node.tx_num;
821 int rx_num = tdata->node.rx_num;
822
823 FTS_TEST_FUNC_ENTER();
824 for (i = 0; i < tx_num; i++) {
825 FTS_TEST_SAVE_INFO("Ch/Tx_%02d: ", i + 1);
826 for (j = 0; j < rx_num; j++) {
827 FTS_TEST_SAVE_INFO("%5d, ", data[i * rx_num + j]);
828 }
829 FTS_TEST_SAVE_INFO("\n");
830 }
831
832 if (key) {
833 FTS_TEST_SAVE_INFO("Ch/Tx_%02d: ", tx_num + 1);
834 for (i = tx_num * rx_num; i < node_num; i++) {
835 FTS_TEST_SAVE_INFO("%5d, ", data[i]);
836 }
837 FTS_TEST_SAVE_INFO("\n");
838 }
839 FTS_TEST_FUNC_EXIT();
840 }
841
842 /*
843 * save_testdata_incell - save data to testdata.csv
844 */
save_data_csv(int * data,char * name,u8 code,bool mc_sc,bool key)845 void save_data_csv(int *data, char *name, u8 code, bool mc_sc, bool key)
846 {
847 #if CSV_SUPPORT
848 int i = 0;
849 int tx = 0;
850 int rx = 0;
851 int csv_node_num = 0;
852 struct fts_test *tdata = fts_ftest;
853 struct fts_test_node *node = NULL;
854 struct csv_format *csv = &tdata->csv;
855
856 FTS_TEST_FUNC_ENTER();
857 if (!csv || !csv->line2_buffer || !csv->data_buffer) {
858 FTS_TEST_ERROR("csv buffer is null");
859 return;
860 }
861
862 if (mc_sc) {
863 node = &tdata->sc_node;
864 tx = 2;
865 } else {
866 node = &tdata->node;
867 tx = node->tx_num;
868 }
869 if (key) {
870 tx++;
871 }
872 rx = node->rx_num;
873 csv_node_num = tx * rx;
874
875 /* line 2 */
876 csv->line2_len += snprintf(csv->line2_buffer + csv->line2_len, \
877 CSV_LINE2_BUFFER_LEN - csv->line2_len,
878 "%s, %d, %d, %d, %d, %d, ", \
879 name, code, tx, rx,
880 csv->start_line, csv->item_count);
881
882 if (csv->line2_len >= CSV_LINE2_BUFFER_LEN - 1) {
883 FTS_TEST_ERROR("csv line2 buffer length(%d) fail", csv->line2_len);
884 }
885 csv->start_line += tx;
886 csv->item_count++;
887
888 /* test data */
889 for (i = 0; i < csv_node_num; i++) {
890 if (((i + 1) % rx) == 0) {
891 csv->data_len += snprintf(csv->data_buffer + csv->data_len, \
892 CSV_DATA_BUFFER_LEN - csv->data_len, \
893 "%d, \n", data[i]);
894 } else {
895 csv->data_len += snprintf(csv->data_buffer + csv->data_len, \
896 CSV_DATA_BUFFER_LEN - csv->data_len, \
897 "%d, ", data[i]);
898 }
899
900 if (csv->data_len >= CSV_DATA_BUFFER_LEN - 1) {
901 FTS_TEST_ERROR("csv data buffer length(%d) fail", csv->data_len);
902 }
903 }
904
905
906 FTS_TEST_FUNC_EXIT();
907 #endif
908 }
909
910
911 /* mc_sc only */
912 /* Only V3 Pattern has mapping & no-mapping */
mapping_switch(u8 mapping)913 int mapping_switch(u8 mapping)
914 {
915 int ret = 0;
916 u8 val = 0xFF;
917 struct fts_test *tdata = fts_ftest;
918
919 if (tdata->v3_pattern) {
920 ret = fts_test_read_reg(FACTORY_REG_NOMAPPING, &val);
921 if (ret < 0) {
922 FTS_TEST_ERROR("read 0x54 register fail");
923 return ret;
924 }
925
926 if (val != mapping) {
927 ret = fts_test_write_reg(FACTORY_REG_NOMAPPING, mapping);
928 if (ret < 0) {
929 FTS_TEST_ERROR("write 0x54 register fail");
930 return ret;
931 }
932 sys_delay(FACTORY_TEST_DELAY);
933 }
934 }
935
936 return 0;
937 }
938
get_fw_wp(u8 wp_ch_sel,enum wp_type water_proof_type)939 bool get_fw_wp(u8 wp_ch_sel, enum wp_type water_proof_type)
940 {
941 bool fw_wp_state = false;
942
943 switch (water_proof_type) {
944 case WATER_PROOF_ON:
945 /* bit5: 0-check in wp on, 1-not check */
946 fw_wp_state = !(wp_ch_sel & 0x20);
947 break;
948 case WATER_PROOF_ON_TX:
949 /* Bit6: 0-check Rx+Tx in wp mode 1-check one channel
950 Bit2: 0-check Tx in wp mode; 1-check Rx in wp mode
951 */
952 fw_wp_state = (!(wp_ch_sel & 0x40) || !(wp_ch_sel & 0x04));
953 break;
954 case WATER_PROOF_ON_RX:
955 fw_wp_state = (!(wp_ch_sel & 0x40) || (wp_ch_sel & 0x04));
956 break;
957 case WATER_PROOF_OFF:
958 /* bit7: 0-check in wp off, 1-not check */
959 fw_wp_state = !(wp_ch_sel & 0x80);
960 break;
961 case WATER_PROOF_OFF_TX:
962 /* Bit1-0: 00-check Tx in non-wp mode
963 01-check Rx in non-wp mode
964 10:check Rx+Tx in non-wp mode
965 */
966 fw_wp_state = ((0x0 == (wp_ch_sel & 0x03)) || (0x02 == (wp_ch_sel & 0x03)));
967 break;
968 case WATER_PROOF_OFF_RX:
969 fw_wp_state = ((0x01 == (wp_ch_sel & 0x03)) || (0x02 == (wp_ch_sel & 0x03)));
970 break;
971 default:
972 break;
973 }
974
975 return fw_wp_state;
976 }
977
get_cb_mc_sc(u8 wp,int byte_num,int * cb_buf,enum byte_mode mode)978 int get_cb_mc_sc(u8 wp, int byte_num, int *cb_buf, enum byte_mode mode)
979 {
980 int ret = 0;
981
982 /* 1:waterproof 0:non-waterproof */
983 ret = fts_test_write_reg(FACTORY_REG_MC_SC_MODE, wp);
984 if (ret < 0) {
985 FTS_TEST_SAVE_ERR("get mc_sc mode fail\n");
986 return ret;
987 }
988
989 /* read cb */
990 ret = get_cb_sc(byte_num, cb_buf, mode);
991 if (ret < 0) {
992 FTS_TEST_SAVE_ERR("get sc cb fail\n");
993 return ret;
994 }
995
996 return 0;
997 }
998
get_rawdata_mc_sc(enum wp_type wp,int * data)999 int get_rawdata_mc_sc(enum wp_type wp, int *data)
1000 {
1001 int ret = 0;
1002 u8 val = 0;
1003 u8 addr = 0;
1004 u8 rawdata_addr = 0;
1005 int byte_num = 0;
1006 struct fts_test *tdata = fts_ftest;
1007
1008 if ((NULL == tdata) || (NULL == tdata->func) ) {
1009 FTS_TEST_ERROR("test/func is null\n");
1010 return -EINVAL;
1011 }
1012
1013 addr = FACTORY_REG_LINE_ADDR;
1014 rawdata_addr = FACTORY_REG_RAWDATA_ADDR_MC_SC;
1015 if (WATER_PROOF_ON == wp) {
1016 val = 0xAC;
1017 } else {
1018 val = 0xAB;
1019 }
1020
1021 byte_num = tdata->sc_node.node_num * 2;
1022 ret = read_rawdata(addr, val, rawdata_addr, byte_num, data);
1023 if (ret < 0) {
1024 FTS_TEST_SAVE_ERR("read rawdata fail\n");
1025 return ret;
1026 }
1027
1028 return 0;
1029 }
1030
get_rawdata_mc(u8 fre,u8 fir,int * rawdata)1031 int get_rawdata_mc(u8 fre, u8 fir, int *rawdata)
1032 {
1033 int ret = 0;
1034 int i = 0;
1035
1036 if (NULL == rawdata ) {
1037 FTS_TEST_SAVE_ERR("rawdata buffer is null\n");
1038 return -EINVAL;
1039 }
1040
1041 /* set frequecy high/low */
1042 ret = fts_test_write_reg(FACTORY_REG_FRE_LIST, fre);
1043 if (ret < 0) {
1044 FTS_TEST_SAVE_ERR("set frequecy fail,ret=%d\n", ret);
1045 return ret;
1046 }
1047
1048 /* fir enable/disable */
1049 ret = fts_test_write_reg(FACTORY_REG_FIR, 1);
1050 if (ret < 0) {
1051 FTS_TEST_SAVE_ERR("set fir fail,ret=%d\n", fir);
1052 return ret;
1053 }
1054
1055 /* get rawdata */
1056 for (i = 0; i < 3; i++) {
1057 /* lost 3 frames, in order to obtain stable data */
1058 ret = get_rawdata(rawdata);
1059 }
1060 if (ret < 0) {
1061 FTS_TEST_SAVE_ERR("get rawdata fail,ret=%d\n", ret);
1062 return ret;
1063 }
1064
1065 return 0;
1066 }
1067
short_print_mc(int * r,int num)1068 void short_print_mc(int *r, int num)
1069 {
1070 int i = 0;
1071
1072 for (i = 0; i < num; i++) {
1073 printk("%4d ", r[i]);
1074 }
1075
1076 printk("\n");
1077 }
1078
short_get_adc_data_mc(u8 retval,int byte_num,int * adc_buf,u8 mode)1079 int short_get_adc_data_mc(u8 retval, int byte_num, int *adc_buf, u8 mode)
1080 {
1081 int ret = 0;
1082 int i = 0;
1083 u8 short_state = 0;
1084
1085 FTS_TEST_FUNC_ENTER();
1086 /* select short test mode & start test */
1087 ret = fts_test_write_reg(FACTROY_REG_SHORT_TEST_EN, mode);
1088 if (ret < 0) {
1089 FTS_TEST_SAVE_ERR("write short test mode fail\n");
1090 goto test_err;
1091 }
1092
1093 for (i = 0; i < FACTORY_TEST_RETRY; i++) {
1094 sys_delay(FACTORY_TEST_RETRY_DELAY);
1095
1096 ret = fts_test_read_reg(FACTROY_REG_SHORT_TEST_EN, &short_state);
1097 if ((ret >= 0) && (retval == short_state))
1098 break;
1099 else
1100 FTS_TEST_DBG("reg%x=%x,retry:%d",
1101 FACTROY_REG_SHORT_TEST_EN, short_state, i);
1102 }
1103 if (i >= FACTORY_TEST_RETRY) {
1104 FTS_TEST_SAVE_ERR("short test timeout, ADC data not OK\n");
1105 ret = -EIO;
1106 goto test_err;
1107 }
1108
1109 ret = read_mass_data(FACTORY_REG_SHORT_ADDR_MC, byte_num, adc_buf);
1110 if (ret < 0) {
1111 FTS_TEST_SAVE_ERR("get short(adc) data fail\n");
1112 }
1113
1114 FTS_TEST_DBG("adc data:\n");
1115 short_print_mc(adc_buf, byte_num / 2);
1116 test_err:
1117 FTS_TEST_FUNC_EXIT();
1118 return ret;
1119 }
1120
compare_mc_sc(bool tx_check,bool rx_check,int * data,int * min,int * max)1121 bool compare_mc_sc(bool tx_check, bool rx_check, int *data, int *min, int *max)
1122 {
1123 int i = 0;
1124 bool result = true;
1125 struct fts_test *tdata = fts_ftest;
1126
1127 if (rx_check) {
1128 for (i = 0; i < tdata->sc_node.rx_num; i++) {
1129 if (0 == tdata->node_valid_sc[i])
1130 continue;
1131
1132 if ((data[i] < min[i]) || (data[i] > max[i])) {
1133 FTS_TEST_SAVE_ERR("test fail,rx%d=%5d,range=(%5d,%5d)\n",
1134 i + 1, data[i], min[i], max[i]);
1135 result = false;
1136 }
1137 }
1138 }
1139
1140 if (tx_check) {
1141 for (i = tdata->sc_node.rx_num; i < tdata->sc_node.node_num; i++) {
1142 if (0 == tdata->node_valid_sc[i])
1143 continue;
1144
1145 if ((data[i] < min[i]) || (data[i] > max[i])) {
1146 FTS_TEST_SAVE_INFO("test fail,tx%d=%5d,range=(%5d,%5d)\n",
1147 i - tdata->sc_node.rx_num + 1,
1148 data[i], min[i], max[i]);
1149 result = false;
1150 }
1151 }
1152 }
1153
1154 return result;
1155 }
1156
show_data_mc_sc(int * data)1157 void show_data_mc_sc(int *data)
1158 {
1159 int i = 0;
1160 struct fts_test *tdata = fts_ftest;
1161
1162 FTS_TEST_SAVE_INFO("SCap Rx: ");
1163 for (i = 0; i < tdata->sc_node.rx_num; i++) {
1164 FTS_TEST_SAVE_INFO( "%5d, ", data[i]);
1165 }
1166 FTS_TEST_SAVE_INFO("\n");
1167
1168 FTS_TEST_SAVE_INFO("SCap Tx: ");
1169 for (i = tdata->sc_node.rx_num; i < tdata->sc_node.node_num; i++) {
1170 FTS_TEST_SAVE_INFO( "%5d, ", data[i]);
1171 }
1172 FTS_TEST_SAVE_INFO("\n");
1173 }
1174 /* mc_sc end*/
1175
1176 /*
1177 * fts_test_save_test_data - Save test data to SD card etc.
1178 */
fts_test_save_test_data(char * file_name,char * data_buf,int len)1179 static int fts_test_save_test_data(char *file_name, char *data_buf, int len)
1180 {
1181 struct file *pfile = NULL;
1182 char filepath[128];
1183 loff_t pos;
1184 mm_segment_t old_fs;
1185
1186 FTS_TEST_FUNC_ENTER();
1187 memset(filepath, 0, sizeof(filepath));
1188 sprintf(filepath, "%s%s", FTS_INI_FILE_PATH, file_name);
1189 if (NULL == pfile) {
1190 pfile = filp_open(filepath, O_TRUNC | O_CREAT | O_RDWR, 0);
1191 }
1192 if (IS_ERR(pfile)) {
1193 FTS_TEST_ERROR("error occured while opening file %s.", filepath);
1194 return -EIO;
1195 }
1196
1197 old_fs = get_fs();
1198 set_fs(KERNEL_DS);
1199 pos = 0;
1200 vfs_write(pfile, data_buf, len, &pos);
1201 filp_close(pfile, NULL);
1202 set_fs(old_fs);
1203
1204 FTS_TEST_FUNC_EXIT();
1205 return 0;
1206 }
1207
fts_test_malloc_free_data_csv(struct fts_test * tdata,bool allocate)1208 static int fts_test_malloc_free_data_csv(struct fts_test *tdata, bool allocate)
1209 {
1210 #if CSV_SUPPORT
1211 struct csv_format *csv = &tdata->csv;
1212
1213 if (true == allocate) {
1214 csv->buffer = vmalloc(CSV_BUFFER_LEN);
1215 if (NULL == csv->buffer) {
1216 FTS_TEST_ERROR("csv->buffer malloc fail\n");
1217 return -ENOMEM;
1218 }
1219 csv->line2_buffer = vmalloc(CSV_LINE2_BUFFER_LEN);
1220 if (NULL == csv->line2_buffer) {
1221 FTS_TEST_ERROR("csv->line2_buffer malloc fail\n");
1222 return -ENOMEM;
1223 }
1224 csv->data_buffer = vmalloc(CSV_DATA_BUFFER_LEN);
1225 if (NULL == csv->data_buffer) {
1226 FTS_TEST_ERROR("csv->data_buffer malloc fail\n");
1227 return -ENOMEM;
1228 }
1229
1230 /* initialize variable */
1231 csv->length = 0;
1232 csv->line2_len = 0;
1233 csv->data_len = 0;
1234 csv->start_line = 11;
1235 csv->item_count = 1;
1236
1237 } else {
1238 if (csv->buffer) {
1239 vfree(csv->buffer);
1240 csv->buffer = NULL;
1241 }
1242 if (csv->line2_buffer) {
1243 vfree(csv->line2_buffer);
1244 csv->line2_buffer = NULL;
1245 }
1246 if (csv->data_buffer) {
1247 vfree(csv->data_buffer);
1248 csv->data_buffer = NULL;
1249 }
1250 }
1251 #endif
1252
1253 return 0;
1254 }
1255
fts_test_malloc_free_data_txt(struct fts_test * tdata,bool allocate)1256 static int fts_test_malloc_free_data_txt(struct fts_test *tdata, bool allocate)
1257 {
1258 if (true == allocate) {
1259 tdata->testresult = vmalloc(TXT_BUFFER_LEN);
1260 if (NULL == tdata->testresult) {
1261 FTS_TEST_ERROR("tdata->testresult malloc fail\n");
1262 return -ENOMEM;
1263 }
1264
1265 tdata->testresult_len = 0;
1266 FTS_TEST_SAVE_INFO("FW version:0x%02x\n", tdata->fw_ver);
1267 FTS_TEST_SAVE_INFO("tx_num:%d, rx_num:%d\n",
1268 tdata->node.tx_num, tdata->node.rx_num);
1269 } else {
1270 if (tdata->testresult) {
1271 vfree(tdata->testresult);
1272 tdata->testresult = NULL;
1273 }
1274 }
1275
1276 return 0;
1277 }
1278
fts_test_save_data_csv(struct fts_test * tdata)1279 static void fts_test_save_data_csv(struct fts_test *tdata)
1280 {
1281 #if CSV_SUPPORT
1282 struct csv_format *csv = &tdata->csv;
1283
1284 if (!csv || !csv->buffer || !csv->line2_buffer || !csv->data_buffer) {
1285 FTS_TEST_ERROR("csv buffer is null");
1286 return;
1287 }
1288
1289 /* line 1 */
1290 csv->length += snprintf(csv->buffer + csv->length, \
1291 CSV_BUFFER_LEN - csv->length, \
1292 "ECC, 85, 170, IC Name, %s, IC Code, %x\n", \
1293 tdata->ini.ic_name, \
1294 (tdata->ini.ic_code >> IC_CODE_OFFSET));
1295
1296 /* line 2 */
1297 csv->length += snprintf(csv->buffer + csv->length, \
1298 CSV_BUFFER_LEN - csv->length, \
1299 "TestItem Num, %d, ", \
1300 csv->item_count);
1301 if (csv->line2_len > 0) {
1302 memcpy(csv->buffer + csv->length, csv->line2_buffer, csv->line2_len);
1303 csv->length += csv->line2_len;
1304 }
1305
1306 /* line 3 ~ 10 "\n" */
1307 csv->length += snprintf(csv->buffer + csv->length, \
1308 CSV_BUFFER_LEN - csv->length, \
1309 "\n\n\n\n\n\n\n\n\n");
1310
1311 /* line 11 ~ data area */
1312 if (csv->data_len > 0) {
1313 memcpy(csv->buffer + csv->length, csv->data_buffer, csv->data_len);
1314 csv->length += csv->data_len;
1315 }
1316
1317 FTS_TEST_INFO("csv length:%d", csv->length);
1318 fts_test_save_test_data(FTS_CSV_FILE_NAME, csv->buffer, csv->length);
1319 #endif
1320 }
1321
fts_test_save_result_txt(struct fts_test * tdata)1322 static void fts_test_save_result_txt(struct fts_test *tdata)
1323 {
1324 if (!tdata || !tdata->testresult) {
1325 FTS_TEST_ERROR("test result is null");
1326 return;
1327 }
1328
1329 FTS_TEST_INFO("test result length in txt:%d", tdata->testresult_len);
1330 fts_test_save_test_data(FTS_TXT_FILE_NAME, tdata->testresult, tdata->testresult_len);
1331 }
1332
fts_test_malloc_free_incell(struct fts_test * tdata,bool allocate)1333 static int fts_test_malloc_free_incell(struct fts_test *tdata, bool allocate)
1334 {
1335 struct incell_threshold *thr = &tdata->ic.incell.thr;
1336 int buflen = tdata->node.node_num * sizeof(int);
1337
1338 if (true == allocate) {
1339 FTS_TEST_INFO("buflen:%d", buflen);
1340 fts_malloc_r(thr->rawdata_min, buflen);
1341 fts_malloc_r(thr->rawdata_max, buflen);
1342 if (tdata->func->rawdata2_support) {
1343 fts_malloc_r(thr->rawdata2_min, buflen);
1344 fts_malloc_r(thr->rawdata2_max, buflen);
1345 }
1346 fts_malloc_r(thr->cb_min, buflen);
1347 fts_malloc_r(thr->cb_max, buflen);
1348 } else {
1349 fts_free(thr->rawdata_min);
1350 fts_free(thr->rawdata_max);
1351 if (tdata->func->rawdata2_support) {
1352 fts_free(thr->rawdata2_min);
1353 fts_free(thr->rawdata2_max);
1354 }
1355 fts_free(thr->cb_min);
1356 fts_free(thr->cb_max);
1357 }
1358
1359 return 0;
1360 }
1361
fts_test_malloc_free_mc_sc(struct fts_test * tdata,bool allocate)1362 static int fts_test_malloc_free_mc_sc(struct fts_test *tdata, bool allocate)
1363 {
1364 struct mc_sc_threshold *thr = &tdata->ic.mc_sc.thr;
1365 int buflen = tdata->node.node_num * sizeof(int);
1366 int buflen_sc = tdata->sc_node.node_num * sizeof(int);
1367
1368 if (true == allocate) {
1369 fts_malloc_r(thr->rawdata_h_min, buflen);
1370 fts_malloc_r(thr->rawdata_h_max, buflen);
1371 if (tdata->func->rawdata2_support) {
1372 fts_malloc_r(thr->rawdata_l_min, buflen);
1373 fts_malloc_r(thr->rawdata_l_max, buflen);
1374 }
1375 fts_malloc_r(thr->tx_linearity_max, buflen);
1376 fts_malloc_r(thr->tx_linearity_min, buflen);
1377 fts_malloc_r(thr->rx_linearity_max, buflen);
1378 fts_malloc_r(thr->rx_linearity_min, buflen);
1379
1380 fts_malloc_r(thr->scap_cb_off_min, buflen_sc);
1381 fts_malloc_r(thr->scap_cb_off_max, buflen_sc);
1382 fts_malloc_r(thr->scap_cb_on_min, buflen_sc);
1383 fts_malloc_r(thr->scap_cb_on_max, buflen_sc);
1384
1385 fts_malloc_r(thr->scap_rawdata_off_min, buflen_sc);
1386 fts_malloc_r(thr->scap_rawdata_off_max, buflen_sc);
1387 fts_malloc_r(thr->scap_rawdata_on_min, buflen_sc);
1388 fts_malloc_r(thr->scap_rawdata_on_max, buflen_sc);
1389
1390 fts_malloc_r(thr->panel_differ_min, buflen);
1391 fts_malloc_r(thr->panel_differ_max, buflen);
1392 } else {
1393 fts_free(thr->rawdata_h_min);
1394 fts_free(thr->rawdata_h_max);
1395 if (tdata->func->rawdata2_support) {
1396 fts_free(thr->rawdata_l_min);
1397 fts_free(thr->rawdata_l_max);
1398 }
1399 fts_free(thr->tx_linearity_max);
1400 fts_free(thr->tx_linearity_min);
1401 fts_free(thr->rx_linearity_max);
1402 fts_free(thr->rx_linearity_min);
1403
1404 fts_free(thr->scap_cb_off_min);
1405 fts_free(thr->scap_cb_off_max);
1406 fts_free(thr->scap_cb_on_min);
1407 fts_free(thr->scap_cb_on_max);
1408
1409 fts_free(thr->scap_rawdata_off_min);
1410 fts_free(thr->scap_rawdata_off_max);
1411 fts_free(thr->scap_rawdata_on_min);
1412 fts_free(thr->scap_rawdata_on_max);
1413
1414 fts_free(thr->panel_differ_min);
1415 fts_free(thr->panel_differ_max);
1416 }
1417
1418 return 0;
1419 }
1420
fts_test_malloc_free_sc(struct fts_test * tdata,bool allocate)1421 static int fts_test_malloc_free_sc(struct fts_test *tdata, bool allocate)
1422 {
1423 struct sc_threshold *thr = &tdata->ic.sc.thr;
1424 int buflen = tdata->node.node_num * sizeof(int);
1425
1426 if (true == allocate) {
1427 fts_malloc_r(thr->rawdata_min, buflen);
1428 fts_malloc_r(thr->rawdata_max, buflen);
1429 fts_malloc_r(thr->cb_min, buflen);
1430 fts_malloc_r(thr->cb_max, buflen);
1431 fts_malloc_r(thr->dcb_sort, buflen);
1432 fts_malloc_r(thr->dcb_base, buflen);
1433 } else {
1434 fts_free(thr->rawdata_min);
1435 fts_free(thr->rawdata_max);
1436 fts_free(thr->cb_min);
1437 fts_free(thr->cb_max);
1438 fts_free(thr->dcb_sort);
1439 fts_free(thr->dcb_base);
1440 }
1441
1442 return 0;
1443 }
1444
fts_test_malloc_free_thr(struct fts_test * tdata,bool allocate)1445 static int fts_test_malloc_free_thr(struct fts_test *tdata, bool allocate)
1446 {
1447 int ret = 0;
1448
1449 if ((NULL == tdata) || (NULL == tdata->func)) {
1450 FTS_TEST_SAVE_ERR("tdata/func is NULL\n");
1451 return -EINVAL;
1452 }
1453
1454 if (true == allocate) {
1455 fts_malloc_r(tdata->node_valid, tdata->node.node_num * sizeof(int));
1456 fts_malloc_r(tdata->node_valid_sc, tdata->sc_node.node_num * sizeof(int));
1457 } else {
1458 fts_free(tdata->node_valid);
1459 fts_free(tdata->node_valid_sc);
1460 }
1461
1462 switch (tdata->func->hwtype) {
1463 case IC_HW_INCELL:
1464 ret = fts_test_malloc_free_incell(tdata, allocate);
1465 break;
1466 case IC_HW_MC_SC:
1467 ret = fts_test_malloc_free_mc_sc(tdata, allocate);
1468 break;
1469 case IC_HW_SC:
1470 ret = fts_test_malloc_free_sc(tdata, allocate);
1471 break;
1472 default:
1473 FTS_TEST_SAVE_ERR("test ic type(%d) fail\n", tdata->func->hwtype);
1474 ret = -EINVAL;
1475 break;
1476 }
1477
1478 return ret;
1479 }
1480
1481 /* default enable all test item */
fts_test_init_item(struct fts_test * tdata)1482 static void fts_test_init_item(struct fts_test *tdata)
1483 {
1484 switch (tdata->func->hwtype) {
1485 case IC_HW_INCELL:
1486 tdata->ic.incell.u.tmp = 0xFFFFFFFF;
1487 break;
1488 case IC_HW_MC_SC:
1489 tdata->ic.mc_sc.u.tmp = 0xFFFFFFFF;
1490 break;
1491 case IC_HW_SC:
1492 tdata->ic.sc.u.tmp = 0xFFFFFFFF;
1493 break;
1494 }
1495 }
1496
get_tx_rx_num(u8 tx_rx_reg,u8 * ch_num,u8 ch_num_max)1497 static int get_tx_rx_num(u8 tx_rx_reg, u8 *ch_num, u8 ch_num_max)
1498 {
1499 int ret = 0;
1500 int i = 0;
1501
1502 for (i = 0; i < 3; i++) {
1503 ret = fts_test_read_reg(tx_rx_reg, ch_num);
1504 if ((ret < 0) || (*ch_num > ch_num_max)) {
1505 sys_delay(50);
1506 } else
1507 break;
1508 }
1509
1510 if (i >= 3) {
1511 FTS_TEST_ERROR("get channel num fail");
1512 return -EIO;
1513 }
1514
1515 return 0;
1516 }
1517
get_channel_num(struct fts_test * tdata)1518 static int get_channel_num(struct fts_test *tdata)
1519 {
1520 int ret = 0;
1521 u8 tx_num = 0;
1522 u8 rx_num = 0;
1523 int key_num = 0;
1524
1525 /* node structure */
1526 if (IC_HW_SC == tdata->func->hwtype) {
1527 ret = get_tx_rx_num(FACTORY_REG_CH_NUM_SC, &tx_num, NUM_MAX_SC);
1528 if (ret < 0) {
1529 FTS_TEST_ERROR("get channel number fail");
1530 return ret;
1531 }
1532
1533 ret = get_tx_rx_num(FACTORY_REG_KEY_NUM_SC, &rx_num, KEY_NUM_MAX);
1534 if (ret < 0) {
1535 FTS_TEST_ERROR("get key number fail");
1536 return ret;
1537 }
1538
1539 tdata->node.tx_num = 2;
1540 tdata->node.rx_num = tx_num / 2;
1541 tdata->node.channel_num = tx_num;
1542 tdata->node.node_num = tx_num;
1543 key_num = rx_num;
1544 } else {
1545 ret = get_tx_rx_num(FACTORY_REG_CHX_NUM, &tx_num, TX_NUM_MAX);
1546 if (ret < 0) {
1547 FTS_TEST_ERROR("get tx_num fail");
1548 return ret;
1549 }
1550
1551 ret = get_tx_rx_num(FACTORY_REG_CHY_NUM, &rx_num, RX_NUM_MAX);
1552 if (ret < 0) {
1553 FTS_TEST_ERROR("get rx_num fail");
1554 return ret;
1555 }
1556
1557 tdata->node.tx_num = tx_num;
1558 tdata->node.rx_num = rx_num;
1559 if (IC_HW_INCELL == tdata->func->hwtype)
1560 tdata->node.channel_num = tx_num * rx_num;
1561 else if (IC_HW_MC_SC == tdata->func->hwtype)
1562 tdata->node.channel_num = tx_num + rx_num;
1563 tdata->node.node_num = tx_num * rx_num;
1564 key_num = tdata->func->key_num_total;
1565 }
1566
1567 /* key */
1568 tdata->node.key_num = key_num;
1569 tdata->node.node_num += tdata->node.key_num;
1570
1571 /* sc node structure */
1572 tdata->sc_node = tdata->node;
1573 if (IC_HW_MC_SC == tdata->func->hwtype) {
1574 if (tdata->v3_pattern) {
1575 ret = get_tx_rx_num(FACTORY_REG_CHX_NUM_NOMAP, &tx_num, TX_NUM_MAX);
1576 if (ret < 0) {
1577 FTS_TEST_ERROR("get no-mappint tx_num fail");
1578 return ret;
1579 }
1580
1581 ret = get_tx_rx_num(FACTORY_REG_CHY_NUM_NOMAP, &rx_num, TX_NUM_MAX);
1582 if (ret < 0) {
1583 FTS_TEST_ERROR("get no-mapping rx_num fail");
1584 return ret;
1585 }
1586
1587 tdata->sc_node.tx_num = tx_num;
1588 tdata->sc_node.rx_num = rx_num;
1589 }
1590 tdata->sc_node.channel_num = tx_num + rx_num;
1591 tdata->sc_node.node_num = tx_num + rx_num;
1592 }
1593
1594 if (tdata->node.tx_num > TX_NUM_MAX) {
1595 FTS_TEST_ERROR("tx num(%d) fail", tdata->node.tx_num);
1596 return -EIO;
1597 }
1598
1599 if (tdata->node.rx_num > RX_NUM_MAX) {
1600 FTS_TEST_ERROR("rx num(%d) fail", tdata->node.rx_num);
1601 return -EIO;
1602 }
1603
1604 FTS_TEST_INFO("node_num:%d, tx:%d, rx:%d", tdata->node.node_num,
1605 tdata->node.tx_num, tdata->node.rx_num);
1606 return 0;
1607 }
1608
get_ic_version(struct fts_test * tdata)1609 static void get_ic_version(struct fts_test *tdata)
1610 {
1611 u8 val[4] = { 0 };
1612
1613 fts_test_read_reg(REG_FW_CHIP_IDH, &val[0]);
1614 fts_test_read_reg(REG_FW_CHIP_IDL, &val[1]);
1615 fts_test_read_reg(REG_FW_IC_TYPE, &val[2]);
1616 fts_test_read_reg(REG_FW_IC_VERSION, &val[3]);
1617
1618 tdata->ic_ver = TEST_IC_VERSION(val[0], val[1], val[2], val[3]);
1619 FTS_TEST_INFO("test ic version:0x%8x", tdata->ic_ver);
1620 }
1621
fts_test_init_basicinfo(struct fts_test * tdata)1622 static int fts_test_init_basicinfo(struct fts_test *tdata)
1623 {
1624 int ret = 0;
1625 u8 val = 0;
1626
1627 if ((NULL == tdata) || (NULL == tdata->func)) {
1628 FTS_TEST_SAVE_ERR("tdata/func is NULL\n");
1629 return -EINVAL;
1630 }
1631
1632 get_ic_version(tdata);
1633
1634 fts_test_read_reg(REG_FW_VERSION, &val);
1635 tdata->fw_ver = val;
1636
1637 if (IC_HW_INCELL == tdata->func->hwtype) {
1638 fts_test_read_reg(REG_VA_TOUCH_THR, &val);
1639 tdata->va_touch_thr = val;
1640 fts_test_read_reg(REG_VKEY_TOUCH_THR, &val);
1641 tdata->vk_touch_thr = val;
1642 }
1643
1644 /* enter factory mode */
1645 ret = enter_factory_mode();
1646 if (ret < 0) {
1647 FTS_TEST_SAVE_ERR("enter factory mode fail\n");
1648 return ret;
1649 }
1650
1651 if (IC_HW_MC_SC == tdata->func->hwtype) {
1652 fts_test_read_reg(FACTORY_REG_PATTERN, &val);
1653 tdata->v3_pattern = (1 == val) ? true : false;
1654 fts_test_read_reg(FACTORY_REG_NOMAPPING, &val);
1655 tdata->mapping = val;
1656 }
1657
1658 /* enter into factory mode and read tx/rx num */
1659 ret = get_channel_num(tdata);
1660 if (ret < 0) {
1661 FTS_TEST_SAVE_ERR("get channel number fail\n");
1662 return ret;
1663 }
1664
1665 return ret;
1666 }
1667
fts_test_main_init(void)1668 static int fts_test_main_init(void)
1669 {
1670 int ret = 0;
1671 struct fts_test *tdata = fts_ftest;
1672
1673 FTS_TEST_FUNC_ENTER();
1674 /* get basic information: tx/rx num ... */
1675 ret = fts_test_init_basicinfo(tdata);
1676 if (ret < 0) {
1677 FTS_TEST_ERROR("test init basicinfo fail");
1678 return ret;
1679 }
1680
1681 /* allocate memory for test threshold */
1682 ret = fts_test_malloc_free_thr(tdata, true);
1683 if (ret < 0) {
1684 FTS_TEST_ERROR("test malloc for threshold fail");
1685 return ret;
1686 }
1687
1688 /* default enable all test item */
1689 fts_test_init_item(tdata);
1690
1691 /* allocate memory for test data:csv&txt */
1692 ret = fts_test_malloc_free_data_csv(tdata, true);
1693 if (ret < 0) {
1694 FTS_TEST_ERROR("allocate memory for test data(csv) fail");
1695 return ret;
1696 }
1697
1698 ret = fts_test_malloc_free_data_txt(tdata, true);
1699 if (ret < 0) {
1700 FTS_TEST_ERROR("allocate memory for test data(txt) fail");
1701 return ret;
1702 }
1703
1704 /* allocate test data buffer */
1705 tdata->buffer_length = (tdata->node.tx_num + 1) * tdata->node.rx_num;
1706 tdata->buffer_length *= sizeof(int);
1707 FTS_TEST_INFO("test buffer length:%d", tdata->buffer_length);
1708 tdata->buffer = (int *)fts_malloc(tdata->buffer_length);
1709 if (NULL == tdata->buffer) {
1710 FTS_TEST_ERROR("test buffer(%d) malloc fail", tdata->buffer_length);
1711 return -ENOMEM;
1712 }
1713 memset(tdata->buffer, 0, tdata->buffer_length);
1714
1715 FTS_TEST_FUNC_EXIT();
1716 return ret;
1717 }
1718
fts_test_main_exit(void)1719 static int fts_test_main_exit(void)
1720 {
1721 struct fts_test *tdata = fts_ftest;
1722
1723 FTS_TEST_FUNC_ENTER();
1724 fts_test_save_data_csv(tdata);
1725 fts_test_save_result_txt(tdata);
1726
1727 /* free memory */
1728 fts_test_malloc_free_data_txt(tdata, false);
1729 fts_test_malloc_free_data_csv(tdata, false);
1730 fts_test_malloc_free_thr(tdata, false);
1731 /*free test data buffer*/
1732 fts_free(tdata->buffer);
1733
1734 FTS_TEST_FUNC_EXIT();
1735 return 0;
1736 }
1737
1738
1739 /*
1740 * fts_test_get_testparams - get test parameter from ini
1741 */
fts_test_get_testparams(char * config_name)1742 static int fts_test_get_testparams(char *config_name)
1743 {
1744 int ret = 0;
1745
1746 ret = fts_test_get_testparam_from_ini(config_name);
1747
1748 return ret;
1749 }
1750
fts_test_start(void)1751 static int fts_test_start(void)
1752 {
1753 int testresult = 0;
1754 struct fts_test *tdata = fts_ftest;
1755
1756 if (tdata && tdata->func && tdata->func->start_test) {
1757 testresult = tdata->func->start_test();
1758 } else {
1759 FTS_TEST_ERROR("test func/start_test func is null");
1760 }
1761
1762 return testresult;
1763 }
1764
1765 /*
1766 * fts_test_entry - test main entry
1767 *
1768 * warning - need disable irq & esdcheck before call this function
1769 *
1770 */
fts_test_entry(char * ini_file_name)1771 static int fts_test_entry(char *ini_file_name)
1772 {
1773 int ret = 0;
1774
1775 /* test initialize */
1776 ret = fts_test_main_init();
1777 if (ret < 0) {
1778 FTS_TEST_ERROR("fts_test_main_init fail");
1779 goto test_err;
1780 }
1781
1782 /*Read parse configuration file*/
1783 FTS_TEST_SAVE_INFO("ini_file_name:%s\n", ini_file_name);
1784 ret = fts_test_get_testparams(ini_file_name);
1785 if (ret < 0) {
1786 FTS_TEST_ERROR("get testparam fail");
1787 goto test_err;
1788 }
1789
1790 /* Start testing according to the test configuration */
1791 /* luoguojin ???? */
1792 if (true == fts_test_start()) {
1793 FTS_TEST_SAVE_INFO("\n\n=======Tp test pass.\n");
1794 } else {
1795 FTS_TEST_SAVE_INFO("\n\n=======Tp test failure.\n");
1796 }
1797
1798 ret = 0;
1799 test_err:
1800 fts_test_main_exit();
1801 enter_work_mode();
1802 return ret;
1803 }
1804
1805 /************************************************************************
1806 * Name: fts_test_show
1807 * Brief: no
1808 * Input: device, device attribute, char buf
1809 * Output: no
1810 * Return: EPERM
1811 ***********************************************************************/
fts_test_show(struct device * dev,struct device_attribute * attr,char * buf)1812 static ssize_t fts_test_show(struct device *dev, struct device_attribute *attr, char *buf)
1813 {
1814 return -EPERM;
1815 }
1816
1817 /************************************************************************
1818 * Name: fts_test_store
1819 * Brief: upgrade from app.bin
1820 * Input: device, device attribute, char buf, char count
1821 * Output: no
1822 * Return: char count
1823 ***********************************************************************/
fts_test_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1824 static ssize_t fts_test_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1825 {
1826 char fwname[128] = {0};
1827 struct fts_ts_data *ts_data = fts_data;
1828 struct input_dev *input_dev;
1829
1830 if (ts_data->suspended) {
1831 FTS_INFO("In suspend, no test, return now");
1832 return -EINVAL;
1833 }
1834
1835 input_dev = ts_data->input_dev;
1836 memset(fwname, 0, sizeof(fwname));
1837 sprintf(fwname, "%s", buf);
1838 fwname[count - 1] = '\0';
1839 FTS_TEST_DBG("fwname:%s.", fwname);
1840
1841 mutex_lock(&input_dev->mutex);
1842 disable_irq(ts_data->irq);
1843
1844 #if defined(FTS_ESDCHECK_EN) && (FTS_ESDCHECK_EN)
1845 fts_esdcheck_switch(DISABLE);
1846 #endif
1847
1848 fts_test_entry(fwname);
1849
1850 #if defined(FTS_ESDCHECK_EN) && (FTS_ESDCHECK_EN)
1851 fts_esdcheck_switch(ENABLE);
1852 #endif
1853
1854 enable_irq(ts_data->irq);
1855 mutex_unlock(&input_dev->mutex);
1856
1857 return count;
1858 }
1859
1860 /* test from test.ini
1861 * example:echo "***.ini" > fts_test
1862 */
1863 static DEVICE_ATTR(fts_test, S_IRUGO | S_IWUSR, fts_test_show, fts_test_store);
1864
1865 /* add your attr in here*/
1866 static struct attribute *fts_test_attributes[] = {
1867 &dev_attr_fts_test.attr,
1868 NULL
1869 };
1870
1871 static struct attribute_group fts_test_attribute_group = {
1872 .attrs = fts_test_attributes
1873 };
1874
fts_test_func_init(void)1875 static int fts_test_func_init(void)
1876 {
1877 int i = 0;
1878 int j = 0;
1879 int ic_stype = fts_data->ic_info.ids.type;
1880 struct test_funcs *func = NULL;
1881 int func_count = sizeof(test_func_list) / sizeof(test_func_list[0]);
1882
1883 FTS_TEST_INFO("init test function");
1884 if (0 == func_count) {
1885 FTS_TEST_SAVE_ERR("test functions list is NULL, fail\n");
1886 return -ENODATA;
1887 }
1888
1889 fts_ftest = (struct fts_test *)kzalloc(sizeof(*fts_ftest), GFP_KERNEL);
1890 if (NULL == fts_ftest) {
1891 FTS_TEST_ERROR("malloc memory for test fail");
1892 return -ENOMEM;
1893 }
1894
1895 for (i = 0; i < func_count; i++) {
1896 func = test_func_list[i];
1897 for (j = 0; j < FTX_MAX_COMPATIBLE_TYPE; j++) {
1898 if (0 == func->ctype[j])
1899 break;
1900 else if (func->ctype[j] == ic_stype) {
1901 FTS_TEST_INFO("match test function,type:%x", (int)func->ctype[j]);
1902 fts_ftest->func = func;
1903 }
1904 }
1905 }
1906 if (NULL == fts_ftest->func) {
1907 FTS_TEST_ERROR("no test function match, can't test");
1908 return -ENODATA;
1909 }
1910
1911 return 0;
1912 }
1913
fts_test_init(struct i2c_client * client)1914 int fts_test_init(struct i2c_client *client)
1915 {
1916 int ret = 0;
1917
1918 FTS_TEST_FUNC_ENTER();
1919
1920 /* get test function, must be the first step */
1921 ret = fts_test_func_init();
1922 if (ret < 0) {
1923 FTS_TEST_SAVE_ERR("test functions init fail\n");
1924 return ret;
1925 }
1926
1927 ret = sysfs_create_group(&client->dev.kobj, &fts_test_attribute_group);
1928 if (0 != ret) {
1929 FTS_TEST_ERROR( "[focal] %s() - ERROR: sysfs_create_group() failed.", __func__);
1930 sysfs_remove_group(&client->dev.kobj, &fts_test_attribute_group);
1931 } else {
1932 FTS_TEST_DBG("[focal] %s() - sysfs_create_group() succeeded.", __func__);
1933 }
1934
1935 FTS_TEST_FUNC_EXIT();
1936
1937 return ret;
1938 }
1939
fts_test_exit(struct i2c_client * client)1940 int fts_test_exit(struct i2c_client *client)
1941 {
1942 FTS_TEST_FUNC_ENTER();
1943
1944 sysfs_remove_group(&client->dev.kobj, &fts_test_attribute_group);
1945 fts_free(fts_ftest);
1946 FTS_TEST_FUNC_EXIT();
1947 return 0;
1948 }
1949