projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / input / touchscreen / mediatek / synaptics_3320_47 / RefCode_F54.c
CommitLineData
6fa3eb70
S		 1// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2// Copyright ?2012 Synaptics Incorporated. All rights reserved.
3//
4// The information in this file is confidential under the terms
5// of a non-disclosure agreement with Synaptics and is provided
6// AS IS.
7//
8// The information in this file shall remain the exclusive property
9// of Synaptics and may be the subject of Synaptics?patents, in
10// whole or part. Synaptics?intellectual property rights in the
11// information in this file are not expressly or implicitly licensed
12// or otherwise transferred to you as a result of such information
13// being made available to you.
14// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
15// FullRawCapacitance Support 0D button
16//
17#include "RefCode_F54.h"
18#if defined(CONFIG_MACH_MSM8974_VU3_KR)
19#include "TestLimits_vu3.h"
20#else
21#include "TestLimits.h"
22#endif
23#if 0
24#ifdef _DEBUG
25#define DEBUG_TOUCH_INFO_MSG(format, ...) TOUCH_INFO_MSG(format, __VA_ARGS__)
26#else
27#define DEBUG_TOUCH_INFO_MSG(format, ...)
28#endif
29
30#ifdef INTERACTIVE_SHELL
31#define EXIT(x) exit(x)
32#else
33void EXIT(int x)
34{
35 fTOUCH_INFO_MSG(stderr, "Press any key to exit.\n");
36 _getch();
37 exit(x);
38}
39#endif
40#endif
41
42//#define TRX_max 32
43#define TRX_mapping_max 54
44#define LOWER_ABS_ADC_RANGE_LIMIT 60
45#define UPPER_ABS_ADC_RANGE_LIMIT 190
46#define LOWER_ABS_RAW_CAP_LIMIT 1000 //fF
47#define UPPER_ABS_RAW_CAP_LIMIT 14000 //fF
48#define REPORT_DATA_OFFEST 3
49#define VERSION "1.0"
50#define TRX_MAX 32
51
52int NSM_TEST;
53
54#if 0
55void fatal(const char *format, ...)
56{
57 va_list ap;
58
59 DEBUG_TOUCH_INFO_MSG("Error in %s on line %d\n", __FILE__, __LINE__);
60
61 va_start(ap, format);
62 vfTOUCH_INFO_MSG(stderr, format, ap);
63 va_end(ap);
64
65 EXIT(EXIT_FAILURE);
66}
67#endif
68
69unsigned int count;
70const unsigned short DefaultTarget = 0;
71const int DefaultTimeout = 10; // In counts
72
73int pageNum = 0;
74int scanMaxPageCount = 5;
75//CCdciApi cdci;
76int input;
77
78bool bHaveF01 = false;
79bool bHaveF11 = false;
80bool bHaveF1A = false;
81bool bHaveF12 = false;
82bool bHaveF34 = false;
83bool bHaveF54 = false;
84bool bHaveF55 = false;
85bool SignalClarityOn = false;
86bool bHaveF54Ctrl07 = false;
87bool bHaveF54Ctrl41 = false;
88bool bHaveF54Ctrl57 = false;
89bool bHavePixelTouchThresholdTuning = false;
90bool bHaveInterferenceMetric = false;
91bool bHaveCtrl11 = false;
92bool bHaveRelaxationControl = false;
93bool bHaveSensorAssignment = false;
94bool bHaveSenseFrequencyControl = false;
95bool bHaveFirmwareNoiseMitigation = false;
96bool bHaveIIRFilter = false;
97bool bHaveCmnRemoval = false;
98bool bHaveCmnMaximum = false;
99bool bHaveTouchHysteresis = false;
100bool bHaveEdgeCompensation = false;
101bool bHavePerFrequencyNoiseControl = false;
102bool bHaveSignalClarity = false;
103bool bHaveMultiMetricStateMachine = false;
104bool bHaveVarianceMetric = false;
105bool bHave0DRelaxationControl = false;
106bool bHave0DAcquisitionControl = false;
107bool bHaveSlewMetric = false;
108bool bHaveHBlank = false;
109bool bHaveVBlank = false;
110bool bHaveLongHBlank = false;
111bool bHaveNoiseMitigation2 = false;
112bool bHaveSlewOption = false;
113bool bHaveEnhancedStretch = false;
114bool bHaveStartupFastRelaxation = false;
115bool bHaveESDControl = false;
116bool bHaveEnergyRatioRelaxation = false;
117bool bHaveCtrl86 = false;
118bool bHaveCtrl87 = false;
119bool bHaveCtrl88 = false;
120bool bHaveCtrl89 = false;
121bool bHaveCtrl90 = false;
122bool bHaveCtrl91 = false;
123bool bHaveCtrl92 = false;
124bool bHaveCtrl93 = false;
125bool bHaveCtrl94 = false;
126bool bHaveCtrl95 = false;
127bool bHaveCtrl96 = false;
128bool bHaveCtrl97 = false;
129bool bHaveCtrl98 = false;
130bool bHaveCtrl99 = false;
131bool bHaveCtrl100 = false;
132bool bHaveCtrl101 = false;
133bool bHaveCtrl102 = false;
134bool bHaveCtrl103 = false;
135bool bHaveCtrl104 = false;
136bool bHaveCtrl105 = false;
137bool bHaveCtrl106 = false;
138bool bHaveCtrl107 = false;
139bool bHaveCtrl108 = false;
140bool bHaveCtrl109 = false;
141bool bHaveCtrl110 = false;
142bool bHaveCtrl111 = false;
143bool bHaveCtrl112 = false;
144bool bHaveCtrl113 = false;
145bool bHaveCtrl114 = false;
146bool bHaveCtrl115 = false;
147bool bHaveCtrl116 = false;
148bool bHaveCtrl117 = false;
149bool bHaveCtrl118 = false;
150bool bHaveCtrl119 = false;
151bool bHaveCtrl120 = false;
152bool bHaveCtrl121 = false;
153bool bHaveCtrl122 = false;
154bool bHaveCtrl123 = false;
155bool bHaveCtrl124 = false;
156bool bHaveCtrl125 = false;
157bool bHaveCtrl126 = false;
158bool bHaveCtrl127 = false;
159bool bHaveCtrl128 = false;
160bool bHaveCtrl129 = false;
161bool bHaveCtrl130 = false;
162bool bHaveCtrl131 = false;
163bool bHaveCtrl132 = false;
164bool bHaveCtrl133 = false;
165bool bHaveCtrl134 = false;
166bool bHaveCtrl135 = false;
167bool bHaveCtrl136 = false;
168bool bHaveCtrl137 = false;
169bool bHaveCtrl138 = false;
170bool bHaveCtrl139 = false;
171bool bHaveCtrl140 = false;
172bool bHaveCtrl141 = false;
173bool bHaveCtrl142 = false;
174bool bHaveCtrl143 = false;
175bool bHaveCtrl144 = false;
176bool bHaveCtrl145 = false;
177bool bHaveCtrl146 = false;
178bool bHaveCtrl147 = false;
179bool bHaveCtrl148 = false;
180bool bHaveCtrl149 = false;
181
182bool bHaveF54Query13 = false;
183bool bHaveF54Query15 = false;
184bool bHaveF54Query16 = false;
185bool bHaveF54Query17 = false;
186bool bHaveF54Query18 = false;
187bool bHaveF54Query19 = false;
188bool bHaveF54Query20 = false;
189bool bHaveF54Query21 = false;
190bool bHaveF54Query22 = false;
191bool bHaveF54Query23 = false;
192bool bHaveF54Query24 = false;
193bool bHaveF54Query25 = false;
194bool bHaveF54Query26 = false;
195bool bHaveF54Query27 = false;
196bool bHaveF54Query28 = false;
197bool bHaveF54Query29 = false;
198bool bHaveF54Query30 = false;
199bool bHaveF54Query31 = false;
200bool bHaveF54Query32 = false;
201bool bHaveF54Query33 = false;
202bool bHaveF54Query34 = false;
203bool bHaveF54Query35 = false;
204bool bHaveF54Query36 = false;
205bool bHaveF54Query37 = false;
206bool bHaveF54Query38 = false;
207
208bool ButtonShared = false;
209
210unsigned char F54DataBase;
211unsigned char F54QueryBase;
212unsigned char F54CommandBase;
213unsigned char F54ControlBase;
214unsigned char F55QueryBase;
215unsigned char F55ControlBase;
216unsigned char F01ControlBase;
217unsigned char F01CommandBase;
218unsigned char RxChannelCount;
219unsigned char TxChannelCount;
220unsigned char TouchControllerFamily;
221unsigned char CurveCompensationMode;
222unsigned char NumberOfSensingFrequencies;
223unsigned char F54Ctrl07Offset;
224unsigned char F54Ctrl41Offset;
225unsigned char F54Ctrl57Offset;
226unsigned char F54Ctrl88Offset;
227unsigned char F54Ctrl89Offset;
228unsigned char F54Ctrl98Offset;
229unsigned char F54Ctrl102Offset;
230unsigned char F54Ctrl149Offset;
231unsigned char F1AControlBase;
232unsigned char F12ControlBase;
233unsigned char F12QueryBase;
234unsigned char F12_2DTxCount;
235unsigned char F12_2DRxCount;
236unsigned char ButtonTx[8];
237unsigned char ButtonRx[8];
238unsigned char ButtonCount;
239unsigned char F12Support;
240unsigned char F12ControlRegisterPresence;
241unsigned char mask;
242
243// Assuming Tx = 32 & Rx = 32 to accommodate any configuration
244short Image1[TRX_max][TRX_max];
245int ImagepF[TRX_max][TRX_max];
246int AbsSigned32Data[TRX_mapping_max];
247unsigned char AbsADCRangeData[TRX_mapping_max];
248unsigned char Data[TRX_max * TRX_max *4];
249unsigned char TRxPhysical[TRX_mapping_max] ;
250
251int MaxArrayLength;
252
253unsigned char TREX_mapped[7] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3f};
254unsigned char TRX_Open[7] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00} ;
255unsigned char TRX_Gnd[7] = {0xff,0xff,0xff,0xff,0x3,0xff,0xfc} ;
256unsigned char TRX_Short[7] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00} ;
257int HighResistanceLowerLimit[3] = {-1000, -1000, -400};
258int HighResistanceUpperLimit[3] = {450, 450, 200};
259unsigned int AbsShort[TRX_max*2] = {0};
260unsigned int AbsOpen[TRX_max*2] = {0};
261int AbsTxShortLimit = 0;
262int AbsRxShortLimit = 0;
263int AbsTxOpenLimit = 0;
264int AbsRxOpenLimit = 1000;
265int AbsRawRef[16] = {77, 11919, 14023, 15163, 16192, 18319, 19337, 21491, 22633, 24692, 26853, 27993, 30147, 32253, 34411, 37605};
266short NoiseDeltaMin[TRX_MAX][TRX_MAX];
267short NoiseDeltaMax[TRX_MAX][TRX_MAX];
268short NoiseLimitLow = -16;
269short NoiseLimitHigh = 16;
270
271enum {
272 STARTTIME,
273 ENDTIME,
274 TIME_PROFILE_MAX
275};
276
277#define get_time_interval(a,b) a>=b ? a-b : 1000000+a-b
278struct timeval t_interval[TIME_PROFILE_MAX];
279static int outbuf = 0;
280static int out_buf = 0;
281char f54_wlog_buf[6000] = {0};
282char wlog_buf[6000] = {0};
283
284
285#define DO_IF(do_work, goto_error) \
286 do { \
287 if(do_work){ \
288 printk(KERN_INFO "[Touch E] Action Failed [%s %d] \n", \
289 __func__, __LINE__); \
290 goto goto_error; \
291 } \
292 } while (0)
293
294
295#define DO_SAFE(do_work, goto_error) \
296 DO_IF(unlikely((do_work) < 0), goto_error)
297
298
299#if 0
300// Read one or more sensor registers. The number of registers to read (starting
301// at address regAddr) is supplied in length, and the data is returned in values[].
302void Read8BitRegisters(unsigned short regAddr, unsigned char *data, int length)
303{
304 unsigned int lengthRead;
305
306 cdci.ReadRegister(DefaultTarget, (unsigned short) I2C_SLAVE_ADDRESS,
307 (unsigned short)regAddr, data, length, lengthRead, DefaultTimeout);
308}
309
310// Write to one or more sensor registers. The number of registers to write (starting
311// at address regAddr) is supplied in length, and the data is supplied in values[].
312void Write8BitRegisters(unsigned short regAddr, unsigned char *data, int length)
313{
314 unsigned int lengthWritten;
315
316 cdci.WriteRegister(DefaultTarget, (unsigned short) I2C_SLAVE_ADDRESS,
317 (unsigned short)regAddr, data, length, lengthWritten, DefaultTimeout);
318}
319#endif
320
321// Function to switch beteen register pages.
322bool switchPage(int page) {
323
324 unsigned char values[1] = {0};
325 unsigned char data = 0;
326
327 pageNum = values[0] = page;
328
329 count = 0;
330 do {
331 Write8BitRegisters(0xFF, values, 1);
332 msleep(1);
333 Read8BitRegisters(0xFF, &data, 1);
334 count++;
335 } while ((int)data != page && (count < DefaultTimeout));
336 if(count >= DefaultTimeout){
337 printk("[s3528]Timeout -- Page switch fail ! \n");
338 return false;
339 }
340 return true;
341}
342
343#if 0
344void LoadTestLimits()
345{
346 xlsWorkBook* pWB;
347 xlsWorkSheet* pWS;
348 int SheetCount, r, c, i, j, temp;
349 struct st_row::st_row_data* row ;
350 int debug_externel_limits = 1;
351 int index, offset;
352
353 pWB=xls_open("..\\Function54RefCode\\TestLimits.xls","UTF-8");
354 if (pWB!=NULL){
355
356 for (i = 0 ; i<pWB->sheets.count ; i++) {
357
358 if (debug_externel_limits){
359 printf("Sheet N%i (%s) pos %i\n", i, pWB->sheets.sheet[i].name,
360 pWB->sheets.sheet[i].filepos);
361 }
362 for (j=0; j < pWB->sheets.count; j++) {
363 if (!strcmp(pWB->sheets.sheet[i].name, SheetName[j])) {
364 //printf("Start to parse limits%s(%d)\n", SheetName[j], j);
365
366 pWS=xls_getWorkSheet(pWB,i);
367 xls_parseWorkSheet(pWS);
368
369 switch (j) {
370 case 0: //"FullRawCapacitance"
371 for (r = 0; r < TxChannelCount; r++) {
372 for (c = 0; c < RxChannelCount; c++) {
373 row = &pWS->rows.row[r+1];
374 if (debug_externel_limits) {
375 //printf("FullRawCapacitance L [%d][%d]%f\n",r,c, pWS->rows.row[r+1].cells.cell[2*c+1].d);
376 //printf("fullrawcapacitance l %f\n", (&row->cells.cell[2*c+1])->d);
377 //printf("fullrawcapacitance h %f\n", (&row->cells.cell[2*c+2])->d);
378 }
379 LowerImageLimit[r][c] = (&row->cells.cell[2*c+1])->d;
380 UpperImageLimit[r][c] = (&row->cells.cell[2*c+2])->d;
381 }
382 }
383 break;
384
385 case 1: //AdcRange
386 for (r = 0; r < TxChannelCount; r++) {
387 for (c = 0; c < RxChannelCount; c++) {
388 row = &pWS->rows.row[r+1];
389 ADCLowerImageLimit[r][c] = (&row->cells.cell[2*c+1])->d;
390 ADCUpperImageLimit[r][c] = (&row->cells.cell[2*c+2])->d;
391 }
392 }
393 break;
394
395 case 2: //SensorSpeed
396 for (r = 0; r < TxChannelCount; r++) {
397 for (c = 0; c < RxChannelCount; c++) {
398 row = &pWS->rows.row[r+1];
399 SensorSpeedLowerImageLimit[r][c] = (&row->cells.cell[2*c+1])->d;
400 SensorSpeedUpperImageLimit[r][c] = (&row->cells.cell[2*c+2])->d;
401 }
402 }
403 break;
404 case 3: //TRxOpen
405 row = &pWS->rows.row[1];
406
407 for(r = 0; r < TRX_mapping_max ; r++){
408 temp = TRxPhysical[r];
409 if ((TRxPhysical[r] != 0xFF) && ((&row->cells.cell[temp + 1])->d > 0)){
410 index = temp / 8;
411 offset = 7- (temp % 8);
412 TRX_Open[index] = TRX_Open[index] + pow(2.0,offset);
413
414 }
415 }
416
417 break;
418 case 4: //TRxGround
419 row = &pWS->rows.row[1];
420 for(r = 0; r < TRX_mapping_max ; r++){
421 temp = TRxPhysical[r];
422 if ((TRxPhysical[r] != 0xFF) && ((&row->cells.cell[temp + 1])->d > 0)){
423 index = temp / 8;
424 offset = 7- (temp % 8);
425 TRX_Gnd[index] = TRX_Gnd[index] + pow(2.0,offset);
426 //printf("trx, %d, row , %3.0f \n",TRxPhysical[r] , (&row->cells.cell[temp + 1])->d );
427 //printf("TRX_G1[%d]\n", TRX_Gnd[2]);
428 }
429 }
430 break;
431 case 5: //TRxToTRxShort
432 row = &pWS->rows.row[1];
433 for(r = 0; r < TRX_mapping_max ; r++){
434 temp = TRxPhysical[r];
435 if ((TRxPhysical[r] != 0xFF) && ((&row->cells.cell[temp + 1])->d > 0)){
436 index = temp / 8;
437 offset = 7- (temp % 8);
438 TRX_Short[index] = TRX_Short[index] + pow(2.0,offset);
439
440 }
441 }
442 break;
443 case 6: //"HighResistance"
444 r = 1;
445 for (c = 0; c < 3 ; c++) {
446 row=&pWS->rows.row[r];
447 HighResistanceLowerLimit[c] = (float)(&row->cells.cell[2*c+1])->d;
448 HighResistanceUpperLimit[c] = (float)(&row->cells.cell[2*c+2])->d;
449 }
450 break;
451 case 7: //MaxMinTest
452 break;
453 case 8://AbsADCRange
454 break;
455 case 9: //AbsDelta
456 break;
457 case 10: //AbsRaw
458 break;
459 default:
460 printf("[%d] Invalid value!\n", i);
461 break;
462 }
463 }
464 }
465 }
466 } else {
467 //Load TRX_Gnd test limit according to Physical TRx mapping.
468
469 for (int k = 0; k < TRX_mapping_max; k++){
470 temp = TRxPhysical[k];
471 if ( temp != 0xFF){
472 index = temp / 8;
473 offset = 7- (temp % 8);
474 TRX_Gnd[index] = TRX_Gnd[index] + pow(2.0,offset);
475 //printf (" TRxPhysical[%d],Index [%d], offset [%d], TRX_Gnd[%d], [%3.0f]\n", TRxPhysical[k],index,offset, TRX_Gnd[index], pow(2.0,offset) );
476 }
477 }
478 printf("Open file failed, use default Test Limit!\n");
479 }
480
481 return;
482}
483#endif
484
485void Reset(void)
486{
487 unsigned char data;
488
489 switchPage(0x00);
490
491 data = 0x01;
492 Write8BitRegisters(F01CommandBase, &data, 1);
493
494 msleep(10);
495}
496
497// Compare Report type #20 data against test limits
498int CompareImageReport(void)
499{
500 bool result = true;
501 int i,j,node_crack_count=0,rx_crack_count=0, row_crack_count = 0;
502
503 //Compare 0D area
504#if defined(CONFIG_MACH_MSM8974_VU3_KR)
505 if (ButtonCount > 0){
506 for(i = 0; i < ButtonCount; i++){
507 for(j=0; j<(int)F12_2DTxCount;j++){
508 if( (LowerImageLimit[j][F12_2DRxCount+i]>0) && (UpperImageLimit[j][F12_2DRxCount+i]>0 )){
509 if ((ImagepF[j][F12_2DRxCount+i] < LowerImageLimit[j][F12_2DRxCount+i]) ||
510 (ImagepF[j][F12_2DRxCount+i] > UpperImageLimit[j][F12_2DRxCount+i])){
511 TOUCH_INFO_MSG("[Touch] ButtonCheck-FAIL Tx[%d] Rx[%d]\n",j,F12_2DRxCount+i);
512 result = false;
513 break;
514 }
515 }
516 }
517 }
518 }
519#else
520 if (ButtonCount > 0){
521 for(i = 0; i < ButtonCount; i++){
522 if ((ImagepF[TxChannelCount-1][F12_2DRxCount + i] < LowerImageLimit[TxChannelCount-1][F12_2DRxCount + i]) ||
523 (ImagepF[TxChannelCount-1][F12_2DRxCount + i] > UpperImageLimit[TxChannelCount-1][F12_2DRxCount + i])) {
524 //printf("Failed: Button area: TxChannel [%d] RxChannel[%d]\n",TxChannelCount-1, F12_2DRxCount + i);
525 result = false;
526 break;
527 }
528 }
529
530 }
531#endif
532 //Compare 2D area
533 for (j = 0; j < (int)F12_2DRxCount; j++){
534 extern int f54_window_crack;
535 extern int f54_window_crack_check_mode;
536
537 rx_crack_count = 0;
538
539
540 for (i = 0; i < (int)F12_2DTxCount; i++){
541
542
543 if ((ImagepF[i][j] < LowerImageLimit[i][j]) || (ImagepF[i][j] > UpperImageLimit[i][j])) {
544 if(f54_window_crack_check_mode) {
545 if (ImagepF[i][j] < 300){
546 rx_crack_count++;
547 node_crack_count++;
548 }
549 else row_crack_count = 0;
550
551 if (F12_2DTxCount<=rx_crack_count) row_crack_count++;
552
553 if (2<row_crack_count){
554 f54_window_crack = 1;
555 break;
556 }
557
558 if((int)(F12_2DTxCount*F12_2DRxCount*20/100)<node_crack_count) {
559 result = false;
560 f54_window_crack = 1;
561 break;
562 }
563
564 TOUCH_INFO_MSG("[Touch] Tx [%d] Rx [%d] node_crack_count %d, row_crack_count %d, raw cap %d\n",i, j,node_crack_count,row_crack_count, ImagepF[i][j]);
565 }
566 else {
567 //printf("Failed: 2D area: Tx [%d] Rx [%d]\n",i, j);
568 //outbuf += sprintf(f54_wlog_buf+outbuf, "FAIL, %d,%d,%d\n", i, j, ImagepF[i][j]);
569 result = false;
570 break;
571 }
572 }
573 }
574 }
575
576 if (result)
577 outbuf += sprintf(f54_wlog_buf+outbuf, "\nFull Raw Capacitance Image Test passed.\n\n");
578 else outbuf += sprintf(f54_wlog_buf+outbuf, "\nFull Raw Capacitance Image Test failed.\n\n");
579
580 return (result)?1:0;
581}
582
583// Compare Report type #4 data against test limits
584int CompareHighResistance(int maxRxpF, int maxTxpF, int minpF )
585{
586 bool result = true;
587
588 if ( maxRxpF > HighResistanceUpperLimit[0] || maxRxpF < HighResistanceLowerLimit[0])
589 result = false;
590 if ( maxTxpF > HighResistanceUpperLimit[1] || maxTxpF < HighResistanceLowerLimit[1])
591 result = false;
592 if ( minpF > HighResistanceUpperLimit[2] || minpF < HighResistanceLowerLimit[2])
593 result = false;
594
595 if (result == false) {
596 TOUCH_INFO_MSG ("HighResistance Test failed.\n");
597 outbuf += sprintf(f54_wlog_buf+outbuf, "HighResistance Test failed.\n\n");
598 } else {
599 TOUCH_INFO_MSG("HighResistance Test passed.\n");
600 outbuf += sprintf(f54_wlog_buf+outbuf, "HighResistance Test passed.\n\n");
601 }
602 return (result)?1:0;
603}
604
605
606// Compare Report type #22 data against test limits
607int CompareSensorSpeedReport(void)
608{
609 bool result = true;
610 int i,j = 0;
611
612 for (i = 0; i < (int)F12_2DTxCount; i++){
613 for (j = 0; j < (int)F12_2DRxCount; j++){
614 //TOUCH_INFO_MSG("Tx[%d] Rx[%d] -> LOWER : %d Upper : %d IMAGE DATA : %d\n", i, j, SensorSpeedLowerImageLimit[i][j], SensorSpeedUpperImageLimit[i][j], ImagepF[i][j]);
615 if ((ImagepF[i][j] < SensorSpeedLowerImageLimit[i][j]) || (ImagepF[i][j] > SensorSpeedUpperImageLimit[i][j])){
616 result = false;
617 TOUCH_INFO_MSG("Failed : Tx[%d] Rx[%d] -> LOWER : %d Upper : %d IMAGE DATA : %d\n", i, j, SensorSpeedLowerImageLimit[i][j], SensorSpeedUpperImageLimit[i][j], ImagepF[i][j]);
618 out_buf += sprintf(wlog_buf+out_buf, "Failed : Tx[%2d] Rx[%2d] = %3d\n", i, j, ImagepF[i][j]);
619 break;
620 }
621 }
622 }
623
624 if (result) {
625 TOUCH_INFO_MSG("Sensor Speed Test passed.\n");
626 out_buf += sprintf(wlog_buf+out_buf, "\nSensor Speed Test passed.\n\n");
627 } else {
628 TOUCH_INFO_MSG("Sensor Speed Test failed.\n");
629 out_buf += sprintf(wlog_buf+out_buf, "\nSensor Speed Test failed.\n\n");
630 }
631
632 return (result)?1:0;
633}
634
635// Compare Report type #23 data against test limits
636int CompareADCReport(void)
637{
638 bool result = true;
639 int i,j = 0;
640
641 for (i = 0; i < (int)F12_2DTxCount; i++){
642 for (j = 0; j < (int)F12_2DRxCount; j++){
643 //TOUCH_INFO_MSG("Tx[%d] Rx[%d] -> LOWER : %d Upper : %d IMAGE DATA : %u\n", i, j, ADCLowerImageLimit[i][j], ADCUpperImageLimit[i][j], Image1[i][j]);
644 if ((Image1[i][j] < ADCLowerImageLimit[i][j]) || (Image1[i][j] > ADCUpperImageLimit[i][j])){
645 out_buf += sprintf(wlog_buf+out_buf, "Failed : Tx[%2d] Rx[%2d] = %3u\n", i, j, Image1[i][j]);
646 result = false;
647 break;
648 }
649 }
650 }
651
652 if (result) {
653 TOUCH_INFO_MSG("ADC Range Test passed.\n");
654 out_buf += sprintf(wlog_buf+out_buf, "\nADC Range Test passed.\n\n");
655 } else {
656 TOUCH_INFO_MSG("ADC Range Test failed.\n");
657 out_buf += sprintf(wlog_buf+out_buf, "\nADC Range Test failed.\n\n");
658 }
659
660 return (result)?1:0;
661}
662
663void CompareAbsADCRangeReport(void)
664{
665 bool result = true;
666 int i = 0;
667
668 for (i = 0; i < RxChannelCount + F12_2DTxCount; i++) {
669 if (i == F12_2DRxCount ){
670 i = RxChannelCount;
671 }
672 if ((AbsADCRangeData[i] < LOWER_ABS_ADC_RANGE_LIMIT) || (AbsADCRangeData[i] > UPPER_ABS_ADC_RANGE_LIMIT)) {
673 result = false;
674 break;
675 }
676 }
677
678 if (result) {
679 TOUCH_INFO_MSG("\nAbs Sensing ADC Range Test Passed.\n");
680 } else {
681 TOUCH_INFO_MSG("\nAbs Sensing ADC Range Test Failed.\n");
682 }
683}
684
685void CompareAbsRawReport(void)
686{
687 bool result = true;
688 int i = 0;
689
690 for (i = 0; i < RxChannelCount + F12_2DTxCount; i++) {
691 if (i == F12_2DRxCount ){
692 i = RxChannelCount;
693 }
694 if ((AbsSigned32Data[i] < LOWER_ABS_RAW_CAP_LIMIT) || (AbsSigned32Data[i] > UPPER_ABS_RAW_CAP_LIMIT)) {
695 result = false;
696 break;
697 }
698 }
699
700 if (result) {
701 TOUCH_INFO_MSG("\nAbs Sensing Raw Capacitance Test Passed.\n");
702 } else {
703 TOUCH_INFO_MSG("\nAbs Sensing Raw Capacitance Test Failed.\n");
704 }
705}
706
707int CompareAbsOpen(void)
708{
709 bool result = true;
710 int i = 0;
711
712 for (i = 0 ;i < ((int)F12_2DRxCount + (int)F12_2DTxCount); i++) {
713 if (i < (int)F12_2DRxCount) {
714 if (AbsOpen[i] <= AbsRxOpenLimit) {
715 result = false;
716 TOUCH_INFO_MSG("RX[%d] failed value: %d\n",i ,AbsOpen[i]);
717 }
718
719 } else {
720 if (AbsOpen[i] <= AbsTxOpenLimit) {
721 result = false;
722 TOUCH_INFO_MSG("TX[%d] failed value: %d\n",i - (int)F12_2DRxCount ,AbsOpen[i]);
723 }
724 }
725
726 }
727
728 TOUCH_INFO_MSG("AbsRxOpenLimit: %d AbsTxOpenLimit : %d\n",AbsRxOpenLimit , AbsTxOpenLimit);
729
730 if (result) {
731 TOUCH_INFO_MSG ("Abs Sensing Open Test Passed.\n");
732 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Open Test passed.\n\n");
733 } else {
734 TOUCH_INFO_MSG("Abs Sensing Open Test Failed.\n");
735 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Open Test failed.\n\n");
736 }
737
738 return (result)?1:0;
739}
740
741int CompareAbsShort(void)
742{
743 bool result = true;
744 int i = 0;
745
746 for (i = 0 ;i < ((int)F12_2DRxCount + (int)F12_2DTxCount); i++) {
747 if (i < (int)F12_2DRxCount) {
748 if (AbsShort[i] >= AbsRxShortLimit) {
749 result = false;
750 TOUCH_INFO_MSG("RX[%d] failed value: %d\n",i ,AbsShort[i]);
751 }
752
753 } else {
754 if (AbsShort[i] >= AbsTxShortLimit) {
755 result = false;
756 TOUCH_INFO_MSG("TX[%d] failed value: %d\n",i - (int)F12_2DRxCount ,AbsShort[i]);
757 }
758
759 }
760
761 }
762
763 TOUCH_INFO_MSG("AbsRxShortLimit: %d AbsTxShortLimit : %d\n",AbsRxShortLimit , AbsTxShortLimit);
764
765 if (result) {
766 TOUCH_INFO_MSG ("Abs Sensing Short Test Passed.\n");
767 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Short Test passed.\n\n");
768 } else {
769 TOUCH_INFO_MSG("Abs Sensing Short Test Failed.\n");
770 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Short Test failed.\n\n");
771 }
772
773 return (result)?1:0;
774
775}
776
777// Compare Report type #24 data against test limits
778void CompareTRexOpenTestReport(int i)
779{
780 int index;
781 for(index = 0; index < 7; index++){
782 if(Data[index] != TRX_Open[index]){
783 TOUCH_INFO_MSG("\nTRex Open Test failed.\n");
784 return;
785 }
786 }
787
788 TOUCH_INFO_MSG("\nTRex Open Test passed.\n");
789}
790
791// Compare Report type #25 data against test limits
792int CompareTRexGroundTestReport(int i)
793{
794 int index;//, offset, temp;
795
796 for(index = 0; index < 7; index++){
797 if(Data[index] != TRX_Gnd[index]){
798 outbuf += sprintf(f54_wlog_buf+outbuf, "\nTRex Ground Test failed.\n\n");
799 }
800 }
801
802 outbuf += sprintf(f54_wlog_buf+outbuf, "\nTRex Ground Test passed.\n\n");
803 return 1;
804}
805
806// Compare Report type #26 data against test limits
807int CompareTRexShortTestReport(int i)
808{
809 int index;//, offset;
810 for(index = 0; index < 7; index++){
811 if(Data[index] != TRX_Short[index]){
812 outbuf += sprintf(f54_wlog_buf+outbuf, "\nTRex-TRex Short Test failed.\n\n");
813 return 0;
814 //TOUCH_INFO_MSG("\nTRex Ground Test failed.\n");
815 //return;
816 }
817 }
818
819 outbuf += sprintf(f54_wlog_buf+outbuf, "\nTRex-TRex Short Test passed.\n\n");
820
821 return 1;
822}
823
824// Compare Report type #2 data against test limits
825int CompareNoiseReport(void)
826{
827 bool result = true;
828 int i,j = 0;
829
830 TOUCH_INFO_MSG("\n\nNoise Test Data :\n");
831 out_buf += sprintf(wlog_buf+out_buf, "\nNoise Test Data : \n");
832 out_buf += sprintf(wlog_buf+out_buf, "==========================================================================================================\n :");
833
834 for (i = 0; i < (int)RxChannelCount; i++)
835 out_buf += sprintf(wlog_buf+out_buf, "%5d ", i);
836
837 out_buf += sprintf(wlog_buf+out_buf, "\n----------------------------------------------------------------------------------------------------------\n");
838 for (i = 0; i < TxChannelCount; i++){
839 printk("[s3528][Touch] Tx[%2d]: ", i);
840 out_buf += sprintf(wlog_buf+out_buf, " %5d : ", i);
841 for (j = 0; j < RxChannelCount; j++){
842 ImagepF[i][j] = NoiseDeltaMax[i][j] - NoiseDeltaMin[i][j];
843 printk("%3d,", ImagepF[i][j]);
844 out_buf += sprintf(wlog_buf+out_buf, "%5d ", ImagepF[i][j]);
845 // int temp = ImagepF[i][j];
846 }
847 printk("\n");
848 out_buf += sprintf(wlog_buf+out_buf, "\n");
849 }
850 out_buf += sprintf(wlog_buf+out_buf, "------------------------------------------------------------------------------------------------------------\n");
851
852 //Compare 0D area
853 /* for (int32_t i = 1; i <= pdt.ButtonCount; i++){
854 if ((ImagepF[pdt.TxChannelCount - i][pdt._2DRxCount] < NoiseLimitLow) || (ImagepF[pdt.TxChannelCount - i][pdt._2DRxCount] > NoiseLimitHigh)){
855 printf("\tFailed: Button area: TxChannel [%d] RxChannel[%d]\n",pdt.TxChannelCount-i, pdt._2DRxCount);
856 result = false;
857 }
858 }
859 */
860 //Compare 2D area
861 for (i = 0; i < F12_2DTxCount; i++){
862 for (j = 0; j < F12_2DRxCount; j++){
863 if ((ImagepF[i][j] < NoiseLimitLow) || (ImagepF[i][j] > NoiseLimitHigh)) {
864 TOUCH_INFO_MSG("\tFailed: 2D area: Tx [%d] Rx [%d]\n",i, j);
865 //out_buf += sprintf(wlog_buf+out_buf, "Failed Tx [%2d] Rx [%2d] = %3d\n", i, j, ImagepF[i][j]);
866 result = false;
867 }
868 }
869 }
870
871 if (result == false) {
872 TOUCH_INFO_MSG ("Noise Test failed.\n");
873 out_buf += sprintf(wlog_buf+out_buf, "\nNoise Test failed.\n\n");
874 } else {
875 TOUCH_INFO_MSG("Noise Test passed.\n");
876 out_buf += sprintf(wlog_buf+out_buf, "\nNoise Test passed.\n\n");
877 }
878
879 return (result)?1:0;
880}
881
882/*
883void ReadImageReport()
884{
885 int32_t k = 0;
886 ReadRMI(pdt.F54.DataBase + REPORT_DATA_OFFEST, &Data[0], pdt.MaxArrayLength);
887
888 printf("Image Data : \n");
889
890 for (int32_t i = 0; i < pdt.TxChannelCount; i++){
891 printf("Tx[%d]: ", i);
892 for (int32_t j = 0; j < pdt.RxChannelCount; j++){
893 Image1[i][j] = (int16_t)Data[k] | ((int16_t)Data[k + 1] << 8);
894 ImagepF[i][j] = Image1[i][j] / 1000.0;
895 printf("%3.3f,", ImagepF[i][j]);
896 //printf("Image Data [%d][%d] = %d\n", i, j, Image1[i][j]);
897 k = k + 2;
898 }
899 printf("\n");
900 }
901 CompareImageReport();
902
903 //Reset Device
904 Reset();
905}
906
907*/
908
909
910// Construct data with Report Type #20 data
911int ReadImageReport(void)
912{
913 int ret = 0;
914 int i,j,k = 0;
915
916 unsigned char data;
917
918
919 //int ReadF54BitRegisters(unsigned short regAddr, unsigned char *data, int length)
920
921 ret = ReadF54BitRegisters((F54DataBase+REPORT_DATA_OFFEST), &Data[0], MaxArrayLength);
922
923 if(ret < 0)
924 {
925 TPD_LOG("F54 Read error");
926 }
927
928 outbuf += sprintf(f54_wlog_buf+outbuf, "\nInfo: Tx = %d Rx = %d \n", (int)TxChannelCount, (int)RxChannelCount);
929 outbuf += sprintf(f54_wlog_buf+outbuf, "Image Data : \n");
930 outbuf += sprintf(f54_wlog_buf+outbuf, "==========================================================================================================\n :");
931
932 for (i = 0; i < (int)RxChannelCount; i++)
933 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", i);
934
935 outbuf += sprintf(f54_wlog_buf+outbuf, "\n----------------------------------------------------------------------------------------------------------\n");
936
937 for (i = 0; i < (int)TxChannelCount; i++){
938 outbuf += sprintf(f54_wlog_buf+outbuf, " %5d : ", i);
939
940
941 for (j = 0; j < (int)RxChannelCount; j++){
942
943 TPD_LOG("Data[k] = %d, Data[k+1] =%d, Data[k]|Data[k+1]<<8 = %d ",Data[k],Data[k+1], ((short)Data[k] | ((short)Data[k+1] << 8)));
944 Image1[i][j] = ((short)Data[k] | ((short)Data[k+1] << 8));
945 ImagepF[i][j] = Image1[i][j];
946 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", ImagepF[i][j]);
947 k = k + 2;
948 }
949
950
951 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
952 }
953 outbuf += sprintf(f54_wlog_buf+outbuf, "------------------------------------------------------------------------------------------------------------\n");
954
955 ret = CompareImageReport();
956 write_log_DS5(NULL, f54_wlog_buf);
957 msleep(30);
958
959 //Reset Device
960 Reset();
961
962 return ret;
963}
964
965// Construct data with Report Type #20 data
966int GetImageReport(char *buf)
967{
968 int ret = 0;
969 int i,j,k = 0;
970
971 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), &Data[0], MaxArrayLength);
972
973 *buf = 0;
974 ret += sprintf(buf+ret, "\n\nInfo: Tx = %d Rx = %d \n\n", (int)TxChannelCount, (int)RxChannelCount);
975 ret += sprintf(buf+ret, "==========================================================================================================\n :");
976
977 for (i = 0; i < (int)RxChannelCount; i++)
978 ret += sprintf(buf+ret, "%5d ", i);
979
980 ret += sprintf(buf+ret, "\n----------------------------------------------------------------------------------------------------------\n");
981
982 for (i = 0; i < (int)TxChannelCount; i++) {
983 ret += sprintf(buf+ret, " %5d : ", i);
984 for (j = 0; j < (int)RxChannelCount; j++) {
985 Image1[i][j] = ((short)Data[k] | (short)Data[k+1] << 8);
986 ImagepF[i][j] = Image1[i][j];
987 ret += sprintf(buf+ret, "%5d ", ImagepF[i][j]);
988 k = k + 2;
989 }
990 ret += sprintf(buf+ret, "\n");
991 }
992 ret += sprintf(buf+ret, "------------------------------------------------------------------------------------------------------------\n");
993
994 //Reset Device
995 Reset();
996
997 return ret;
998}
999
1000// Construct data with Report Type #2 data
1001int ReadNoiseReport(void)
1002{
1003 int ret = 0;
1004 int i,j,k = 0;
1005
1006 //set FIFO index
1007 unsigned char fifoIndex[2] = {0, 0};
1008 Write8BitRegisters(F54DataBase + 1, fifoIndex, sizeof(fifoIndex));
1009
1010 ReadF54BitRegisters((F54DataBase+REPORT_DATA_OFFEST), &Data[0], MaxArrayLength);
1011
1012 for (i = 0; i < (int)TxChannelCount; i++) {
1013 for (j = 0; j < (int)RxChannelCount; j++) {
1014 Image1[i][j] = (short)Data[k] | ((short)Data[k + 1] << 8);
1015 ImagepF[i][j] = Image1[i][j];
1016
1017 if (ImagepF[i][j] < NoiseDeltaMin[i][j])
1018 {
1019 NoiseDeltaMin[i][j] = ImagepF[i][j];
1020 }
1021 if (ImagepF[i][j] > NoiseDeltaMax[i][j])
1022 {
1023 NoiseDeltaMax[i][j] = ImagepF[i][j];
1024 }
1025
1026 k = k + 2;
1027 }
1028 }
1029 ret = CompareNoiseReport();
1030 write_log_DS5(NULL, wlog_buf);
1031 msleep(30);
1032
1033 Reset();
1034
1035 return ret ;
1036}
1037
1038// Construct data with Report Type #4 data
1039int ReadHighResistanceReport(void)
1040{
1041 short maxRx, maxTx, min;
1042 int maxRxpF, maxTxpF, minpF;
1043 int ret = 0;
1044 int i = 0;
1045
1046 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, 6);
1047
1048 maxRx = ((short)Data[0] | (short)Data[1] << 8);
1049 maxTx = ((short)Data[2] | (short)Data[3] << 8);
1050 min = ((short)Data[4] | (short)Data[5] << 8);
1051
1052 maxRxpF = maxRx;
1053 maxTxpF = maxTx;
1054 minpF = min;
1055
1056 outbuf += sprintf(f54_wlog_buf+outbuf, "Max Rx Offset(pF) = %d\n", maxRxpF);
1057 outbuf += sprintf(f54_wlog_buf+outbuf, "Max Tx Offset(pF) = %d\n", maxTxpF);
1058 outbuf += sprintf(f54_wlog_buf+outbuf, "Min(pF) = %d\n", minpF);
1059
1060 outbuf += sprintf(f54_wlog_buf+outbuf, "\n=====================================================\n");
1061 outbuf += sprintf(f54_wlog_buf+outbuf, "\tHigh Resistance Test\n");
1062 outbuf += sprintf(f54_wlog_buf+outbuf, "=====================================================\n");
1063 outbuf += sprintf(f54_wlog_buf+outbuf, " Parameters: ");
1064 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d %5d %5d ", maxRxpF, maxTxpF, minpF);
1065 outbuf += sprintf(f54_wlog_buf+outbuf, "\n\n Limits(+) : ");
1066 for(i = 0; i < 3; i++)
1067 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", HighResistanceUpperLimit[i]);
1068
1069 outbuf += sprintf(f54_wlog_buf+outbuf, "\n Limits(-) : ");
1070 for(i = 0; i < 3; i++)
1071 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", HighResistanceLowerLimit[i]);
1072
1073 outbuf += sprintf(f54_wlog_buf+outbuf, "\n-----------------------------------------------------\n");
1074
1075 ret = CompareHighResistance(maxRxpF, maxTxpF, minpF);
1076 write_log_DS5(NULL, f54_wlog_buf);
1077 msleep(30);
1078
1079 //Reset Device
1080 Reset();
1081
1082 return ret;
1083}
1084
1085// Construct data with Report Type #13 data
1086void ReadMaxMinReport(void)
1087{
1088 short max, min;
1089 int maxpF, minpF;
1090
1091 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, 4);
1092
1093 max = ((short)Data[0] | (short)Data[1] << 8);
1094 min = ((short)Data[2] | (short)Data[3] << 8);
1095 maxpF = max;
1096 minpF = min;
1097
1098 TOUCH_INFO_MSG("\nRaw Capacitance Maximum and Minimum Test:\n");
1099 /*TOUCH_INFO_MSG("Max = 0x%x\n", max);
1100 TOUCH_INFO_MSG("Min = 0x%x\n", min);*/
1101 TOUCH_INFO_MSG("Max(pF) = %d\n", maxpF);
1102 TOUCH_INFO_MSG("Min(pF) = %d\n", minpF);
1103
1104 //Reset Device
1105 Reset();
1106}
1107
1108// Construct data with Report Type #23 data
1109int ReadADCRangeReport(void)
1110{
1111 int temp = TxChannelCount;
1112 int ret = 0;
1113 int i, j, k = 0;
1114
1115 if (SignalClarityOn){
1116 if ((TxChannelCount / 4) != 0) {
1117 temp = (4 - (TxChannelCount % 4)) + TxChannelCount;
1118 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, (temp * RxChannelCount * 2));
1119 }
1120 } else {
1121 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), &Data[0], MaxArrayLength);
1122 }
1123
1124 k = 0;
1125
1126 TOUCH_INFO_MSG("ADC Range Data: \n");
1127 //outbuf += sprintf(f54_wlog_buf+outbuf, "ADC Range Test Data : \n");
1128 for (i = 0; i < (int)TxChannelCount; i++){
1129 //printk("[Touch] Tx[%2d]: ", i);
1130 //outbuf += sprintf(f54_wlog_buf+outbuf, " %5d : ", i);
1131 for (j = 0; j < (int)RxChannelCount; j++){
1132 //Image1[i][j] = ((unsigned short)Data[k] | (unsigned short)Data[k+1] << 8);
1133 Image1[i][j] = ((unsigned short)Data[k]);
1134 //ImagepF[i][j] = Image1[i][j]/1000.0;
1135 //printk("%3u,", Image1[i][j]);
1136 //outbuf += sprintf(f54_wlog_buf+outbuf, "%5u ", Image1[i][j]);
1137 k = k + 2;
1138 }
1139 //printk("\n");
1140 //outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1141 }
1142
1143 ret = CompareADCReport();
1144 write_log_DS5(NULL, wlog_buf);
1145 msleep(20);
1146
1147 //Reset Device
1148 Reset();
1149
1150 return ret;
1151}
1152
1153void ReadAbsADCRangeReport(void)
1154{
1155 int i, k = 0;
1156
1157 Read8BitRegisters((F54DataBase + REPORT_DATA_OFFEST), &Data[0], 2 * (RxChannelCount + TxChannelCount));
1158
1159 TOUCH_INFO_MSG("Abs Sensing ADC Range Data:\n");
1160 TOUCH_INFO_MSG("Rx: ");
1161 for (i = 0; i < (int)RxChannelCount; i++) {
1162 AbsADCRangeData[k / 2] = (unsigned char)Data[k];
1163 TOUCH_INFO_MSG("%d ", AbsADCRangeData[k / 2]);
1164 k = k + 2;
1165 }
1166 TOUCH_INFO_MSG("\n");
1167 TOUCH_INFO_MSG("Tx: ");
1168 for (i = 0; i < (int)TxChannelCount; i++) {
1169 AbsADCRangeData[k / 2] = (unsigned char)Data[k];
1170 TOUCH_INFO_MSG("%d ", AbsADCRangeData[k / 2]);
1171 k = k + 2;
1172 }
1173 TOUCH_INFO_MSG("\n");
1174
1175 CompareAbsADCRangeReport();
1176
1177 Reset();
1178}
1179
1180void ReadAbsDeltaReport(void)
1181{
1182 int i, k = 0;
1183 int *p32data;
1184
1185 Read8BitRegisters((F54DataBase + REPORT_DATA_OFFEST), &Data[0], 4 * (RxChannelCount + TxChannelCount));
1186
1187 p32data = (int *)&Data[0];
1188
1189 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Delta Capacitance Data:\n");
1190 outbuf += sprintf(f54_wlog_buf+outbuf, "Rx: ");
1191 for (i = 0; i < (int)RxChannelCount; i++) {
1192 AbsSigned32Data[k] = (int)*p32data;
1193 outbuf += sprintf(f54_wlog_buf+outbuf, "%d ", AbsSigned32Data[k]);
1194 k++;
1195 p32data++;
1196 }
1197
1198 outbuf += sprintf(f54_wlog_buf+outbuf, "\nTx: ");
1199 for (i = 0; i < (int)TxChannelCount; i++) {
1200 AbsSigned32Data[k] = (int)*p32data;
1201 outbuf += sprintf(f54_wlog_buf+outbuf, "%d ", AbsSigned32Data[k]);
1202 k++;
1203 p32data++;
1204 }
1205
1206 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1207 Reset();
1208}
1209
1210void ReadAbsRawReport(void)
1211{
1212 int i, k = 0;
1213 int *p32data;
1214
1215 Read8BitRegisters((F54DataBase + REPORT_DATA_OFFEST), &Data[0], 4 * (RxChannelCount + TxChannelCount));
1216
1217 p32data = (int *)&Data[0];
1218
1219 TOUCH_INFO_MSG("Abs Sensing Raw Capacitance Data:\n");
1220 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Raw Capacitance Data:\n");
1221 TOUCH_INFO_MSG("Rx: ");
1222 outbuf += sprintf(f54_wlog_buf+outbuf, "Rx: ");
1223 for (i = 0; i < (int)RxChannelCount; i++) {
1224 AbsSigned32Data[k] = (int)*p32data;
1225 TOUCH_INFO_MSG("%d ", AbsSigned32Data[k]);
1226 outbuf += sprintf(f54_wlog_buf+outbuf, "%d ", AbsSigned32Data[k]);
1227 k++;
1228 p32data++;
1229 }
1230 TOUCH_INFO_MSG("\n");
1231 TOUCH_INFO_MSG("Tx: ");
1232 outbuf += sprintf(f54_wlog_buf+outbuf, "\nTx: ");
1233 for (i = 0; i < (int)TxChannelCount; i++) {
1234 AbsSigned32Data[k] = (int)*p32data;
1235 TOUCH_INFO_MSG("%d ", AbsSigned32Data[k]);
1236 outbuf += sprintf(f54_wlog_buf+outbuf, "%d ", AbsSigned32Data[k]);
1237 k++;
1238 p32data++;
1239 }
1240 //TOUCH_INFO_MSG("\n");
1241 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1242
1243 CompareAbsRawReport();
1244
1245 Reset();
1246}
1247
1248// Construct data with Report Type #38 data
1249int ReadAbsRawOpen(void)
1250{
1251 int i = 0;
1252 int ret = 0;
1253 unsigned char k = 0;
1254
1255 Read8BitRegisters((F54DataBase + REPORT_DATA_OFFEST), &Data[0], (F12_2DRxCount + F12_2DTxCount) * 4);
1256
1257 //TOUCH_INFO_MSG("Abs Sensing Open Test Data:\n");
1258 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Open Test Data:\n");
1259
1260 for(i = 0; i < ((int)F12_2DRxCount + (int)F12_2DTxCount); i++)
1261 {
1262
1263 AbsOpen[i] = (unsigned int)Data[k] | ((unsigned int)Data[k + 1] << 8) |
1264 ((unsigned int)Data[k + 2] << 16) | ((unsigned int)Data[k + 3] << 24);
1265
1266 k += 4;
1267
1268 if (i < (int)F12_2DRxCount) {
1269 //TOUCH_INFO_MSG("RX[%d]: %d, ", i, AbsOpen[i]);
1270 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", AbsOpen[i]);
1271 }
1272 else {
1273 //TOUCH_INFO_MSG("TX[%d]: %d, ", i - (int)F12_2DRxCount, AbsOpen[i]);
1274 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", AbsOpen[i]);
1275 }
1276
1277 if(i == ((int)F12_2DRxCount - 1)) {
1278 //TOUCH_INFO_MSG("\n");
1279 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1280 }
1281 }
1282 //TOUCH_INFO_MSG("\n");
1283
1284 ret = CompareAbsOpen();
1285
1286 return ret;
1287}
1288
1289// Construct data with Report Type #38 data
1290int ReadAbsRawShort(void)
1291{
1292 int i = 0;
1293 int ret = 0;
1294 unsigned char k = 0;
1295
1296 Read8BitRegisters((F54DataBase + REPORT_DATA_OFFEST), &Data[0], (F12_2DRxCount + F12_2DTxCount) * 4);
1297
1298 //TOUCH_INFO_MSG("Abs Sensing Short Test Data:\n");
1299 outbuf += sprintf(f54_wlog_buf+outbuf, "Abs Sensing Short Test Data:\n");
1300
1301 for(i = 0; i < ((int)F12_2DRxCount + (int)F12_2DTxCount); i++ )
1302 {
1303
1304 AbsShort[i] = (unsigned int)Data[k] | ((unsigned int)Data[k + 1] << 8) |
1305 ((unsigned int)Data[k + 2] << 16) | ((unsigned int)Data[k + 3] << 24);
1306
1307 k += 4;
1308
1309 if (i < (int)F12_2DRxCount) {
1310 //TOUCH_INFO_MSG("RX[%d]: %d, ", i, AbsShort[i]);
1311 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", AbsShort[i]);
1312 }
1313 else {
1314 //TOUCH_INFO_MSG("TX[%d]: %d, ", i - (int)F12_2DRxCount, AbsShort[i]);
1315 outbuf += sprintf(f54_wlog_buf+outbuf, "%5d ", AbsShort[i]);
1316 }
1317
1318 if(i == ((int)F12_2DRxCount - 1)) {
1319 //TOUCH_INFO_MSG("\n");
1320 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1321 }
1322 }
1323 //TOUCH_INFO_MSG("\n");
1324
1325 ret = CompareAbsShort();
1326
1327 return ret;
1328}
1329
1330// Construct data with Report Type #22 data
1331int ReadSensorSpeedReport(void)
1332{
1333 int i,j,k = 0;
1334 int ret = 0;
1335
1336 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), &Data[0], MaxArrayLength);
1337
1338 //TOUCH_INFO_MSG("Sensor speed Test Data : \n");
1339 //outbuf += sprintf(f54_wlog_buf+outbuf, "Sensor speed Test Data:\n");
1340
1341 for (i = 0; i < (int)TxChannelCount; i++)
1342 {
1343 //printk("[Touch] Tx[%2d]: ", i);
1344 //outbuf += sprintf(f54_wlog_buf+outbuf, "Tx[%d]: ", i);
1345 for (j = 0; j < (int)RxChannelCount; j++)
1346 {
1347 Image1[i][j] = ((short)Data[k] | (short)Data[k+1] << 8);
1348 ImagepF[i][j] = Image1[i][j];
1349 //printk("%3d,", ImagepF[i][j]);
1350 //outbuf += sprintf(f54_wlog_buf+outbuf, "%d ", ImagepF[i][j]);
1351 k = k + 2;
1352 }
1353 //printk("\n");
1354 //outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1355 }
1356
1357 ret = CompareSensorSpeedReport();
1358 write_log_DS5(NULL, wlog_buf);
1359 msleep(20);
1360
1361 //Reset Device
1362 Reset();
1363
1364 return ret;
1365}
1366
1367int pow_func(int x, int y)
1368{
1369 int result = 1;
1370 int i = 0;
1371 for(i = 0; i < y; i++)
1372 result *= x;
1373 return result;
1374}
1375
1376// Construct data with Report Type #24 data
1377void ReadTRexOpenReport(void)
1378{
1379 int i, j = 0;
1380 //int k = ((int)TxChannelCount) / 8 + 1;
1381 int k = 7, mask = 0x01, value;// Hardcode for Waikiki Test and it support up to 54 Tx
1382
1383 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, k);
1384
1385 for (i = 0; i < k ; i++){
1386 value = Data[i];
1387 Data[i] = 0;
1388 for (j = 0; j < 8; j++){
1389 if((value & mask) == 1) {
1390 Data[i] = Data[i] + (unsigned char)pow_func(2, (7 - j));
1391 }
1392 value >>= 1;
1393 }
1394 //TOUCH_INFO_MSG("TRex-Open Test Data = %#x,", Data[i]);
1395 }
1396 //TOUCH_INFO_MSG("\n");
1397
1398 CompareTRexOpenTestReport(k * 8);
1399
1400 //Reset Device
1401 Reset();
1402}
1403
1404// Construct data with Report Type #25 data
1405int ReadTRexGroundReport(void)
1406{
1407 int ret = 0;
1408 int i,j = 0;
1409 //int k = ((int)TxChannelCount) / 8 + 1;
1410 int k = 7, mask = 0x01, value;// Hardcode for Waikiki Test and it support up to 54 Tx
1411 ReadF54BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, k);
1412
1413 for (i = 0; i < k; i++){
1414 value = Data[i];
1415 Data[i] = 0;
1416 for (j = 0; j < 8; j++){
1417 if((value & mask) == 1) {
1418 Data[i] = Data[i] + (unsigned char)pow_func(2, (7 - j));
1419 }
1420 value >>= 1;
1421 }
1422
1423 outbuf += sprintf(f54_wlog_buf+outbuf, "TRex-Ground Test Data = %#x\n", Data[i]);
1424 }
1425 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1426
1427 ret = CompareTRexGroundTestReport(k * 8);
1428 write_log_DS5(NULL, f54_wlog_buf);
1429 msleep(30);
1430 //Reset Device
1431 Reset();
1432
1433 return ret;
1434}
1435
1436// Construct data with Report Type #26 data
1437int ReadTRexShortReport(void)
1438{
1439 int ret = 0;
1440 int i, j = 0;
1441 //int k = ((int)TxChannelCount) / 8 + 1;
1442 int k = 7, mask = 0x01, value;// Hardcode for Waikiki Test and it support up to 54 Tx
1443 char buf[40] = {0};
1444
1445 ReadF54BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, k);
1446
1447 for (i = 0; i < k; i++) {
1448 value = Data[i];
1449 Data[i] = 0;
1450 ret = 0;
1451 for (j = 0; j < 8; j++){
1452 if((value & mask) == 1) {
1453 Data[i] = Data[i] + (unsigned char)pow_func(2, (7 - j));
1454 ret += sprintf(buf+ret, "%d ", (i * 8 + (7 - j)));
1455 }
1456 value >>= 1;
1457 }
1458 outbuf += sprintf(f54_wlog_buf+outbuf, "TRex-TRex Short Test Data = %#x", Data[i]);
1459
1460 if (ret) {
1461 outbuf += sprintf(f54_wlog_buf+outbuf, " (Short TRx Number: ");
1462 outbuf += sprintf(f54_wlog_buf+outbuf, buf);
1463 outbuf += sprintf(f54_wlog_buf+outbuf, ")");
1464 }
1465 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1466 }
1467
1468 outbuf += sprintf(f54_wlog_buf+outbuf, "\n");
1469
1470 ret = CompareTRexShortTestReport(k * 8);
1471 write_log_DS5(NULL, f54_wlog_buf);
1472 msleep(30);
1473
1474 //Reset Device
1475 Reset();
1476
1477 return ret;
1478}
1479// Function to handle report reads based on user input
1480int ReadReport(unsigned char input, char *buf)
1481{
1482 int ret = 0;
1483 unsigned char data;
1484
1485 //Set the GetReport bit to run the AutoScan
1486 data = 0x01;
1487 Write8BitRegisters(F54CommandBase, &data, 1);
1488
1489 count = 0;
1490 do {
1491 Read8BitRegisters(F54CommandBase, &data, 1);
1492 msleep(1);
1493 count++;
1494 } while (data != 0x00 && (count < DefaultTimeout));
1495 if(count >= DefaultTimeout) {
1496 outbuf += sprintf(f54_wlog_buf+outbuf, "Timeout -- Not supported Report Type in FW\n");
1497 Reset();
1498 return ret;
1499 }
1500
1501 do_gettimeofday(&t_interval[ENDTIME]);
1502
1503 TOUCH_INFO_MSG("Takes %lu ticks\n", get_time_interval(t_interval[ENDTIME].tv_sec,t_interval[STARTTIME].tv_sec));
1504
1505 switch (input){
1506 case 'a':
1507 ret = ReadImageReport();
1508 break;
1509 case 'b':
1510 ret = ReadADCRangeReport();
1511 break;
1512 case 'c':
1513 ret = ReadSensorSpeedReport();
1514 break;
1515 case 'd':
1516 // fTOUCH_INFO_MSG(stderr, "Press any key to continue after you have lowered the bar.\n");
1517 // _getch();
1518 ReadTRexOpenReport();
1519 break;
1520 case 'e':
1521 ret = ReadTRexGroundReport();
1522 break;
1523 case 'f':
1524 ret = ReadTRexShortReport();
1525 break;
1526 case 'g':
1527 ret = ReadHighResistanceReport();
1528 break;
1529 case 'h':
1530 ReadMaxMinReport();
1531 break;
1532 case 'i':
1533 ReadAbsADCRangeReport();
1534 break;
1535 case 'j':
1536 ReadAbsDeltaReport();
1537 break;
1538 case 'k':
1539 ReadAbsRawReport();
1540 break;
1541 case 'l':
1542 ret = GetImageReport(buf);
1543 break;
1544 case 'm':
1545 ret = ReadNoiseReport();
1546 break;
1547 case 'n':
1548 ret = ReadAbsRawShort();
1549 break;
1550 case 'o':
1551 ret = ReadAbsRawOpen();
1552 break;
1553 default:
1554 break;
1555 }
1556
1557 return ret;
1558}
1559
1560#if 0
1561// Power up the sensor, configure the Control Bridge protocol converter to use the appropriate protocol.
1562EError PowerOnSensor()
1563{
1564 EError nRet;
1565 nRet = cdci.Connect();
1566 nRet = cdci.PowerOn((unsigned short)0, SENSOR_VDD_SUPPLY_MV, SENSOR_SUPPLY_MV, SENSOR_SUPPLY_MV, DefaultTimeout);
1567 if (nRet == 0){
1568 nRet = cdci.ConfigI2CReg((unsigned short)0, ERmiAddressEightBit,EPullupsYes, ELowSpeed, EAttnLow, DefaultTimeout);
1569 }
1570 return nRet;
1571}
1572
1573// Remove power from the sensor.
1574EError PowerOffSensor()
1575{
1576 EError nRet;
1577
1578 nRet = cdci.PowerOff(DefaultTarget, DefaultTimeout);
1579 cdci.Disconnect();
1580 return nRet;
1581}
1582#endif
1583
1584// Examples of reading query registers. Real applications often do not need to read query registers at all.
1585void RunQueries(void)
1586{
1587
1588 unsigned short cAddr = 0xEE;
1589 unsigned char cFunc = 0;
1590 int rxCount = 0;
1591 int txCount = 0;
1592 int offset = 0;
1593 int query_offset = 0;
1594 int i,j = 0;
1595#if defined(CONFIG_MACH_MSM8974_VU3_KR)
1596 int k = 0;
1597 int cnt = 0;
1598#endif
1599
1600 // Scan Page Description Table (PDT) to find all RMI functions presented by this device.
1601 // The Table starts at $00EE. This and every sixth register (decrementing) is a function number
1602 // except when this "function number" is $00, meaning end of PDT.
1603 // In an actual use case this scan might be done only once on first run or before compile.
1604 do{
1605 Read8BitRegisters(cAddr, &cFunc, 1);
1606 if (cFunc == 0){
1607 break;
1608 }
1609 printk("[s3528]F0x%x\n",cFunc);
1610 switch (cFunc){
1611 case 0x01:
1612 if (!bHaveF01){
1613 Read8BitRegisters((cAddr-3), &F01ControlBase, 1);
1614 Read8BitRegisters((cAddr-4), &F01CommandBase, 1);
1615 break;
1616 }
1617#if defined(CONFIG_MACH_MSM8974_VU3_KR)
1618 case 0x1a:
1619 if(!bHaveF1A){
1620 k =0;
1621 Read8BitRegisters((cAddr-3), &F1AControlBase, 1);
1622 Read8BitRegisters(F1AControlBase+1, &ButtonCount, 1);
1623 //ButtonCount = log((double)ButtonCount+1 )/ log(2.0);
1624 while(ButtonCount){
1625 cnt++;
1626 ButtonCount=(ButtonCount>>1);
1627 }
1628 ButtonCount=cnt;
1629 for (i = 0; i < ButtonCount; i++){
1630 Read8BitRegisters(F1AControlBase + 3 + k, &ButtonTx[i], 1);
1631 Read8BitRegisters(F1AControlBase + 3 + k + 1 , &ButtonRx[i], 1);
1632 k= k +2;
1633 }
1634 TOUCH_INFO_MSG("Have 1A:%d,%d\n",ButtonTx[1], ButtonRx[1]);
1635 bHaveF1A = true;
1636 }
1637 break;
1638#endif
1639 case 0x12:
1640 if(!bHaveF12){
1641 Read8BitRegisters((cAddr-3), &F12ControlBase, 1);
1642 Read8BitRegisters((cAddr-5), &F12QueryBase, 1);
1643 Read8BitRegisters((F12QueryBase), &F12Support, 1);
1644
1645 if( (F12Support | 0x00) == 0 ){
1646 //TOUCH_INFO_MSG("Device not support F12.\n");
1647 break;
1648 }
1649 Read8BitRegisters((F12QueryBase+5), Data, 2);
1650 mask = 0x01;
1651 for (j = 0; j < 8; j++){
1652 if((Data[1] & mask) == 1) offset++;
1653 Data[1] >>= 1;
1654 }
1655 Read8BitRegisters((F12ControlBase + offset), Data, 14);
1656 F12_2DRxCount = Data[12];
1657 F12_2DTxCount = Data[13];
1658
1659 if(TRX_max<=F12_2DRxCount)
1660 F12_2DRxCount = TRX_max;
1661 if(TRX_max<=F12_2DTxCount)
1662 F12_2DTxCount = 16;
1663
1664 offset = 0;
1665 break;
1666 }
1667 case 0x54:
1668 if (!bHaveF54){
1669 Read8BitRegisters((cAddr-2), &F54DataBase, 1);
1670
1671 Read8BitRegisters((cAddr-3), &F54ControlBase, 1);
1672 Read8BitRegisters((cAddr-4), &F54CommandBase, 1);
1673 Read8BitRegisters((cAddr-5), &F54QueryBase, 1);
1674
1675 Read8BitRegisters(F54QueryBase, &RxChannelCount, 1);
1676 Read8BitRegisters((F54QueryBase+1), &TxChannelCount, 1);
1677
1678 if(TRX_max<=RxChannelCount)
1679 RxChannelCount = TRX_max;
1680 if(TRX_max<=TxChannelCount)
1681 TxChannelCount = 16;
1682
1683 MaxArrayLength = (int)RxChannelCount * (int)TxChannelCount * 2;
1684
1685 Read8BitRegisters(F54QueryBase, Data, 60);
1686
1687 TouchControllerFamily = Data[5];
1688 offset++; //Ctrl 00
1689
1690
1691 if (TouchControllerFamily == 0x0 || TouchControllerFamily == 0x01)
1692 offset++; //Ctrl 01
1693 offset+=2; //Ctrl 02
1694 bHavePixelTouchThresholdTuning = ((Data[6] & 0x01) == 0x01);
1695 if (bHavePixelTouchThresholdTuning)
1696 offset++; //Ctrl 03;
1697 if (TouchControllerFamily == 0x0 || TouchControllerFamily == 0x01)
1698 offset+=3; //Ctrl 04/05/06
1699 if (TouchControllerFamily == 0x01){
1700 F54Ctrl07Offset = offset;
1701 offset++; //Ctrl 07;
1702 bHaveF54Ctrl07 = true;
1703 }
1704 if (TouchControllerFamily == 0x0 || TouchControllerFamily == 0x01)
1705 offset+=2; //Ctrl 08
1706 if (TouchControllerFamily == 0x0 || TouchControllerFamily == 0x01)
1707 offset++; //Ctrl 09
1708 bHaveInterferenceMetric = ((Data[7] & 0x02) == 0x02);
1709 if (bHaveInterferenceMetric)
1710 offset++; // Ctrl 10
1711 bHaveCtrl11 = ((Data[7] & 0x10) == 0x10);
1712 if (bHaveCtrl11) offset+=2; //Ctrl 11
1713 bHaveRelaxationControl = ((Data[7] & 0x80) == 0x80);
1714 if (bHaveRelaxationControl)
1715 offset+=2; //Ctrl 12/13
1716 bHaveSensorAssignment = ((Data[7] & 0x01) == 0x01);
1717 if (bHaveSensorAssignment)
1718 offset++; //Ctrl 14
1719 if (bHaveSensorAssignment) offset+=RxChannelCount; //Ctrl 15
1720 if (bHaveSensorAssignment) offset+=TxChannelCount; //Ctrl 16
1721 bHaveSenseFrequencyControl = ((Data[7] & 0x04) == 0x04);
1722
1723 if (bHaveSenseFrequencyControl) NumberOfSensingFrequencies = (Data[13] & 0x0F);
1724
1725 if (bHaveSenseFrequencyControl) offset+=(3*(int)NumberOfSensingFrequencies); //Ctrl 17/18/19
1726 offset++; //Ctrl 20
1727 if (bHaveSenseFrequencyControl) offset+=2; //Ctrl 21
1728 bHaveFirmwareNoiseMitigation = ((Data[7] & 0x08) == 0x08);
1729 if (bHaveFirmwareNoiseMitigation) offset++; //Ctrl 22
1730 if (bHaveFirmwareNoiseMitigation) offset+=2; //Ctrl 23
1731 if (bHaveFirmwareNoiseMitigation) offset+=2; //Ctrl 24
1732 if (bHaveFirmwareNoiseMitigation) offset++; //Ctrl 25
1733 if (bHaveFirmwareNoiseMitigation) offset++; //Ctrl 26
1734 bHaveIIRFilter = ((Data[9] & 0x02) == 0x02);
1735 if (bHaveIIRFilter) offset++; //Ctrl 27
1736 if (bHaveFirmwareNoiseMitigation) offset+=2; //Ctrl 28
1737 bHaveCmnRemoval = ((Data[9] & 0x04) == 0x04);
1738 bHaveCmnMaximum = ((Data[9] & 0x08) == 0x08);
1739 if (bHaveCmnRemoval) offset++; //Ctrl 29
1740 if (bHaveCmnMaximum) offset++; //Ctrl 30
1741 bHaveTouchHysteresis = ((Data[9] & 0x10) == 0x10);
1742 if (bHaveTouchHysteresis) offset++; //Ctrl 31
1743 bHaveEdgeCompensation = ((Data[9] & 0x20) == 0x20);
1744 if (bHaveEdgeCompensation) offset+=2; //Ctrl 32
1745 if (bHaveEdgeCompensation) offset+=2; //Ctrl 33
1746 if (bHaveEdgeCompensation) offset+=2; //Ctrl 34
1747
1748 if (bHaveEdgeCompensation) offset+=2; //Ctrl 35
1749 CurveCompensationMode = (Data[8] & 0x03);
1750
1751 if (CurveCompensationMode == 0x02) {
1752 offset += (int)RxChannelCount;
1753 } else if (CurveCompensationMode == 0x01) {
1754 offset += ((int)RxChannelCount > (int)TxChannelCount) ? (int)RxChannelCount: (int)TxChannelCount;
1755 } //Ctrl 36
1756
1757 if (CurveCompensationMode == 0x02) offset += (int)TxChannelCount; //Ctrl 37
1758 bHavePerFrequencyNoiseControl = ((Data[9] & 0x40) == 0x40);
1759 if (bHavePerFrequencyNoiseControl) offset+=(3*(int)NumberOfSensingFrequencies); //Ctrl 38/39/40
1760 bHaveSignalClarity = ((Data[10] & 0x04) == 0x04);
1761 if (bHaveSignalClarity){
1762
1763
1764 F54Ctrl41Offset = offset; //Ctrl 41
1765 offset++;
1766
1767 SignalClarityOn = true;
1768
1769 }
1770 else SignalClarityOn = false;
1771
1772 bHaveMultiMetricStateMachine = ((Data[10] & 0x02) == 0x02);
1773 bHaveVarianceMetric = ((Data[10] & 0x08) == 0x08);
1774 if (bHaveVarianceMetric) offset+=2; //Ctr 42
1775 if (bHaveMultiMetricStateMachine) offset+=2; //Ctrl 43
1776 if (bHaveMultiMetricStateMachine) offset+=11 ; //Ctrl 44/45/46/47/48/49/50/51/52/53/54
1777 bHave0DRelaxationControl = ((Data[10] & 0x10) == 0x10);
1778 bHave0DAcquisitionControl = ((Data[10] & 0x20) == 0x20);
1779
1780 if (bHave0DRelaxationControl) offset+=2; //Ctrl 55/56
1781
1782 if (bHave0DAcquisitionControl)
1783
1784 TPD_LOG("bHaveSignalClarity");{
1785 F54Ctrl57Offset = offset;
1786 offset++; //Ctrl 57;
1787 bHaveF54Ctrl57 = true;
1788 }
1789 if (bHave0DAcquisitionControl) offset += 1; //Ctrl 58
1790 bHaveSlewMetric = ((Data[10] & 0x80) == 0x80);
1791 bHaveHBlank = ((Data[11] & 0x01) == 0x01);
1792 bHaveVBlank = ((Data[11] & 0x02) == 0x02);
1793 bHaveLongHBlank = ((Data[11] & 0x04) == 0x04);
1794 bHaveNoiseMitigation2 = ((Data[11] & 0x20) == 0x20);
1795 bHaveSlewOption = ((Data[12] & 0x02) == 0x02);
1796 if (bHaveHBlank) offset += 1; //Ctrl 59
1797 if (bHaveHBlank || bHaveVBlank || bHaveLongHBlank) offset +=3; //Ctrl 60/61/62
1798 if (bHaveSlewMetric || bHaveHBlank || bHaveVBlank || bHaveLongHBlank || bHaveNoiseMitigation2 || bHaveSlewOption) offset += 1; //Ctrl 63
1799 if (bHaveHBlank) offset += 28; //Ctrl 64/65/66/67
1800 else if (bHaveVBlank || bHaveLongHBlank) offset += 4; //Ctrl 64/65/66/67
1801 if (bHaveHBlank || bHaveVBlank || bHaveLongHBlank) offset += 8; //Ctrl 68/69/70/71/72/73
1802 if (bHaveSlewMetric) offset += 2; //Ctrl 74
1803 bHaveEnhancedStretch = ((Data[9] & 0x80) == 0x80);
1804 if (bHaveEnhancedStretch) offset += (int)NumberOfSensingFrequencies; //Ctrl 75
1805 bHaveStartupFastRelaxation = ((Data[11] & 0x08) == 0x08);
1806 if (bHaveStartupFastRelaxation) offset += 1; //Ctrl 76
1807 bHaveESDControl = ((Data[11] & 0x10) == 0x10);
1808 if (bHaveESDControl) offset += 2; //Ctrl 77/78
1809 if (bHaveNoiseMitigation2) offset += 5; //Ctrl 79/80/81/82/83
1810 bHaveEnergyRatioRelaxation = ((Data[11] & 0x80) == 0x80);
1811 if (bHaveEnergyRatioRelaxation) offset += 2; //Ctrl 84/85
1812 bHaveF54Query13 = ((Data[12] & 0x08) == 0x08);
1813 if (bHaveSenseFrequencyControl){
1814 query_offset = 13;
1815 NumberOfSensingFrequencies = (Data[13] & 0x0F);
1816 }
1817 else
1818 query_offset = 12;
1819 if (bHaveF54Query13) query_offset++;
1820 bHaveCtrl86 = (bHaveF54Query13 && ((Data[13] & 0x01) == 0x01));
1821 bHaveCtrl87 = (bHaveF54Query13 && ((Data[13] & 0x02) == 0x02));
1822 bHaveCtrl88 = ((Data[12] & 0x40) == 0x40);
1823 if (bHaveCtrl86) offset += 1; //Ctrl 86
1824 if (bHaveCtrl87) offset += 1; //Ctrl 87
1825 if (bHaveCtrl88){
1826 F54Ctrl88Offset = offset;
1827 offset++; //Ctrl 88;
1828 }
1829 bHaveCtrl89 = ((Data[query_offset] & 0x20) == 0x20);
1830 if (bHaveCtrl89) offset++;
1831 bHaveF54Query15 = ((Data[12] & 0x80) == 0x80);
1832 if (bHaveF54Query15) query_offset++;
1833 bHaveCtrl90 = (bHaveF54Query15 && ((Data[query_offset] & 0x01) == 0x01));
1834 if (bHaveCtrl90) offset++; //offset = 1b
1835 bHaveF54Query16 = ((Data[query_offset] & 0x8) == 0x8);
1836
1837 bHaveF54Query20 = ((Data[query_offset] & 0x10) == 0x10);
1838 bHaveF54Query21 = ((Data[query_offset] & 0x20) == 0x20);
1839
1840 bHaveF54Query22 = ((Data[query_offset] & 0x40) == 0x40);
1841 bHaveF54Query25 = ((Data[query_offset] & 0x80) == 0x80);
1842 if (bHaveF54Query16) query_offset++; //query_offset = 15
1843 bHaveF54Query17 = ((Data[query_offset] & 0x1) == 0x1);
1844 bHaveCtrl92 = ((Data[query_offset] & 0x4) == 0x4);
1845 bHaveCtrl93 = ((Data[query_offset] & 0x8) == 0x8);
1846 bHaveCtrl94 = ((Data[query_offset] & 0x10) == 0x10);
1847 bHaveF54Query18 = bHaveCtrl94;
1848 bHaveCtrl95 = ((Data[query_offset] & 0x20) == 0x20);
1849 bHaveF54Query19 = bHaveCtrl95;
1850 bHaveCtrl99 = ((Data[query_offset] & 0x40) == 0x40);
1851 bHaveCtrl100 = ((Data[query_offset] & 0x80) == 0x80);
1852 if (bHaveF54Query17) query_offset++; //query_offset = 16
1853 if (bHaveF54Query18) query_offset++; //query_offset = 17
1854 if (bHaveF54Query19) query_offset++; //query_offset = 18
1855
1856 if (bHaveF54Query20) query_offset++; //query_offset = 19
1857 if (bHaveF54Query21) query_offset++; //query_offset = 20
1858
1859 bHaveCtrl91 = ((Data[query_offset] & 0x4) == 0x4);
1860 bHaveCtrl96 = ((Data[query_offset] & 0x8) == 0x8);
1861 bHaveCtrl97 = ((Data[query_offset] & 0x10) == 0x10);
1862 bHaveCtrl98 = ((Data[query_offset] & 0x20) == 0x20);
1863
1864 bHaveF54Query24 = ((Data[query_offset] & 0x80) == 0x80);
1865
1866 if (bHaveF54Query22) query_offset++; //query_offset = 21
1867 bHaveCtrl101 = ((Data[query_offset] & 0x2) == 0x2);
1868 bHaveF54Query23 = ((Data[query_offset] & 0x8) == 0x8);
1869
1870 bHaveF54Query26 = ((Data[query_offset] & 0x10) == 0x10);
1871 bHaveCtrl103= ((Data[query_offset] & 0x10) == 0x10);
1872 bHaveCtrl104 = ((Data[query_offset] & 0x20) == 0x20);
1873 bHaveCtrl105 = ((Data[query_offset] & 0x40) == 0x40);
1874 bHaveF54Query28 = ((Data[query_offset] & 0x80) == 0x80);
1875
1876 if (bHaveF54Query23) {
1877 query_offset++; //query_offset = 22
1878 bHaveCtrl102 = ((Data[query_offset] & 0x01) == 0x01);
1879 }
1880 else
1881 bHaveCtrl102 = false;
1882 if (bHaveCtrl91) offset++;
1883 if (bHaveCtrl92) offset++;
1884 if (bHaveCtrl93) offset++;
1885 if (bHaveCtrl94) offset++;
1886 if (bHaveCtrl95) offset++;
1887 if (bHaveCtrl96) offset++;
1888 if (bHaveCtrl97) offset++;
1889 if (bHaveCtrl98)
1890 {
1891 F54Ctrl98Offset = offset;
1892 offset++;
1893 }
1894 if (bHaveCtrl99) offset++;
1895 if (bHaveCtrl100) offset++;
1896 if (bHaveCtrl101) offset++;
1897
1898 if (bHaveF54Query24) query_offset++;
1899 query_offset++; //Query 25
1900 bHaveCtrl106 = ((Data[query_offset] & 0x01) == 0x01);
1901 bHaveCtrl107 = ((Data[query_offset] & 0x04) == 0x04);
1902 bHaveCtrl108 = ((Data[query_offset] & 0x08) == 0x08);
1903 bHaveCtrl109 = ((Data[query_offset] & 0x10) == 0x10);
1904 bHaveF54Query27 = ((Data[query_offset] & 0x80) == 0x80);
1905 if (bHaveF54Query26) query_offset++;
1906 if (bHaveF54Query27) {
1907 query_offset++;
1908 bHaveCtrl110 = ((Data[query_offset] & 0x01) == 0x01);
1909 bHaveCtrl111 = ((Data[query_offset] & 0x04) == 0x04);
1910 bHaveCtrl112 = ((Data[query_offset] & 0x08) == 0x08);
1911 bHaveCtrl113 = ((Data[query_offset] & 0x10) == 0x10);
1912 bHaveCtrl114 = ((Data[query_offset] & 0x40) == 0x40);
1913 bHaveF54Query29 = ((Data[query_offset] & 0x80) == 0x80);
1914 }
1915 if (bHaveF54Query28) query_offset++;
1916 if (bHaveF54Query29) {
1917 query_offset++;
1918 bHaveCtrl115 = ((Data[query_offset] & 0x01) == 0x01);
1919 bHaveCtrl116 = ((Data[query_offset] & 0x10) == 0x10);
1920 bHaveF54Query30 = ((Data[query_offset] & 0x80) == 0x80);
1921 }
1922 if (bHaveF54Query30) {
1923 query_offset++;
1924 bHaveCtrl119 = ((Data[query_offset] & 0x02) == 0x02);
1925 bHaveCtrl120 = ((Data[query_offset] & 0x04) == 0x04);
1926 bHaveCtrl121 = ((Data[query_offset] & 0x08) == 0x08);
1927 bHaveCtrl122 = ((Data[query_offset] & 0x10) == 0x10);
1928 bHaveF54Query31 = ((Data[query_offset] & 0x10) == 0x10);
1929 bHaveCtrl123 = ((Data[query_offset] & 0x40) == 0x40);
1930 bHaveF54Query32 = ((Data[query_offset] & 0x80) == 0x80);
1931 }
1932 if (bHaveF54Query31) query_offset++;
1933 if (bHaveF54Query32) {
1934 query_offset++;
1935 bHaveCtrl125 = ((Data[query_offset] & 0x01) == 0x01);
1936 bHaveCtrl126 = ((Data[query_offset] & 0x02) == 0x02);
1937 bHaveCtrl127 = ((Data[query_offset] & 0x04) == 0x04);
1938 bHaveF54Query33 = ((Data[query_offset] & 0x10) == 0x10);
1939 bHaveF54Query34 = ((Data[query_offset] & 0x40) == 0x40);
1940 bHaveF54Query35 = ((Data[query_offset] & 0x80) == 0x80);
1941 }
1942 if (bHaveF54Query33) {
1943 query_offset++;
1944 bHaveCtrl132 = ((Data[query_offset] & 0x10) == 0x10);
1945 bHaveCtrl133 = ((Data[query_offset] & 0x20) == 0x20);
1946 bHaveCtrl134 = ((Data[query_offset] & 0x40) == 0x40);
1947 bHaveF54Query36 = ((Data[query_offset] & 0x80) == 0x80);
1948 }
1949 if (bHaveF54Query34) query_offset++;
1950 if (bHaveF54Query35) {
1951 query_offset++;
1952 bHaveCtrl137 = ((Data[query_offset] & 0x08) == 0x08);
1953 bHaveCtrl138 = ((Data[query_offset] & 0x10) == 0x10);
1954 bHaveCtrl139 = ((Data[query_offset] & 0x20) == 0x20);
1955 bHaveCtrl140 = ((Data[query_offset] & 0x80) == 0x80);
1956 }
1957 if (bHaveF54Query36) {
1958 query_offset++;
1959 bHaveCtrl142 = ((Data[query_offset] & 0x02) == 0x02);
1960 bHaveF54Query37 = ((Data[query_offset] & 0x04) == 0x04);
1961 bHaveCtrl143 = ((Data[query_offset] & 0x08) == 0x08);
1962 bHaveCtrl144 = ((Data[query_offset] & 0x10) == 0x10);
1963 bHaveCtrl145 = ((Data[query_offset] & 0x20) == 0x20);
1964 bHaveCtrl146 = ((Data[query_offset] & 0x40) == 0x40);
1965 bHaveF54Query38 = ((Data[query_offset] & 0x80) == 0x80);
1966 }
1967 if (bHaveF54Query37) query_offset++;
1968 if (bHaveF54Query38) {
1969 query_offset++;
1970 bHaveCtrl147 = ((Data[query_offset] & 0x01) == 0x01);
1971 bHaveCtrl148 = ((Data[query_offset] & 0x02) == 0x02);
1972 bHaveCtrl149 = ((Data[query_offset] & 0x04) == 0x04);
1973 }
1974 //-----------------------------------------------------------from Ctrl 103
1975 bHaveCtrl117 = true; //Reserved
1976 bHaveCtrl118 = false; //Reserved
1977 bHaveCtrl124 = false; //Reserved
1978 bHaveCtrl128 = false; //Reserved
1979 bHaveCtrl129 = false; //Reserved
1980 bHaveCtrl130 = false; //Reserved
1981 bHaveCtrl131 = false; //Reserved
1982 bHaveCtrl135 = false; //Reserved
1983 bHaveCtrl136 = false; //Reserved
1984 bHaveCtrl141 = false; //Reserved
1985 offset = offset - 1;
1986 if (bHaveCtrl103) offset++;
1987 if (bHaveCtrl104) offset++;
1988 if (bHaveCtrl105) offset++;
1989 if (bHaveCtrl106) offset++;
1990 if (bHaveCtrl107) offset++;
1991 if (bHaveCtrl108) offset++;
1992 if (bHaveCtrl109) offset++;
1993 if (bHaveCtrl110) offset++;
1994 if (bHaveCtrl111) offset++;
1995 if (bHaveCtrl112) offset++;
1996 if (bHaveCtrl113) offset++;
1997 if (bHaveCtrl114) offset++;
1998 if (bHaveCtrl115) offset++;
1999 if (bHaveCtrl116) offset++;
2000 if (bHaveCtrl117) offset++;
2001 if (bHaveCtrl118) offset++;
2002 if (bHaveCtrl119) offset++;
2003 if (bHaveCtrl120) offset++;
2004 if (bHaveCtrl121) offset++;
2005 if (bHaveCtrl122) offset++;
2006 if (bHaveCtrl123) offset++;
2007 if (bHaveCtrl124) offset++;
2008 if (bHaveCtrl125) offset++;
2009 if (bHaveCtrl126) offset++;
2010 if (bHaveCtrl127) offset++;
2011 if (bHaveCtrl128) offset++;
2012 if (bHaveCtrl129) offset++;
2013 if (bHaveCtrl130) offset++;
2014 if (bHaveCtrl131) offset++;
2015 if (bHaveCtrl132) offset++;
2016 if (bHaveCtrl133) offset++;
2017 if (bHaveCtrl134) offset++;
2018 if (bHaveCtrl135) offset++;
2019 if (bHaveCtrl136) offset++;
2020 if (bHaveCtrl137) offset++;
2021 if (bHaveCtrl138) offset++;
2022 if (bHaveCtrl139) offset++;
2023 if (bHaveCtrl140) offset++;
2024 if (bHaveCtrl141) offset++;
2025 if (bHaveCtrl142) offset++;
2026 if (bHaveCtrl143) offset++;
2027 if (bHaveCtrl144) offset++;
2028 if (bHaveCtrl145) offset++;
2029 if (bHaveCtrl146) offset++;
2030 if (bHaveCtrl147) offset++;
2031 if (bHaveCtrl148) offset++;
2032 if (bHaveCtrl149){
2033 offset++;
2034 F54Ctrl149Offset = offset;
2035 }
2036 break;
2037 }
2038 case 0x55:
2039 if (!bHaveF55){
2040 Read8BitRegisters((cAddr-3), &F55ControlBase, 1);
2041 Read8BitRegisters((cAddr-5), &F55QueryBase, 1);
2042
2043 Read8BitRegisters(F55QueryBase, &RxChannelCount, 1);
2044 Read8BitRegisters((F55QueryBase+1), &TxChannelCount, 1);
2045
2046 rxCount = 0;
2047 txCount = 0;
2048 //Read Sensor Mapping
2049 Read8BitRegisters((F55ControlBase+1), Data, (int)RxChannelCount);
2050 for (i = 0; i < (int)RxChannelCount; i++){
2051 if (Data[i] != 0xFF){
2052 rxCount++;
2053 TRxPhysical[i] = Data[i];
2054 }
2055 else
2056 break;
2057 }
2058 Read8BitRegisters((F55ControlBase+2), Data, (int)TxChannelCount);
2059 for (i = 0; i < (int)TxChannelCount; i++){
2060 if (Data[i] != 0xFF ){
2061 TRxPhysical[rxCount + i] = Data[i];
2062 txCount++;
2063 }
2064 else
2065 break;
2066 }
2067 for (i = (rxCount + txCount); i < (TRX_mapping_max); i++){
2068 TRxPhysical[i] = 0xFF;
2069 }
2070
2071 RxChannelCount = rxCount;
2072 TxChannelCount = txCount;
2073 if(TRX_max<=RxChannelCount)
2074 RxChannelCount = TRX_max;
2075 if(TRX_max<=TxChannelCount)
2076 TxChannelCount = 16;
2077
2078 MaxArrayLength = (int)RxChannelCount * (int)TxChannelCount * 2;
2079 if(((int)TxChannelCount - F12_2DTxCount == 0) && ButtonCount > 0){
2080 ButtonShared = true;
2081 }
2082
2083 break;
2084 }
2085 default: // Any other function
2086 break;
2087 }
2088 cAddr -= 6;
2089 } while (true);
2090}
2091
2092// The following function is necessary to setup the Function $54 tests. The setup needs to be done once
2093// after entering into page 0x01. As long as the touch controller stays in page 1, the setup does not
2094// need to be repeated.
2095bool TestPreparation(void)
2096{
2097 unsigned char data = 0;
2098 unsigned char addr = 0;
2099
2100 //if (!switchPage(0x01))
2101 // return false;
2102
2103 // Turn off CBC.
2104 if (bHaveF54Ctrl07) {
2105 addr = F54ControlBase + F54Ctrl07Offset;
2106 Read8BitRegisters(addr, &data, 1);
2107 // data = data & 0xEF;
2108 data = 0;
2109 Write8BitRegisters(addr, &data, 1);
2110 }
2111 else if (bHaveCtrl88){
2112 addr = F54ControlBase + F54Ctrl88Offset;
2113 Read8BitRegisters(addr, &data, 1);
2114 data = data & 0xDF;
2115 Write8BitRegisters(addr, &data, 1);
2116 }
2117
2118 // Turn off CBC2
2119 if (bHaveCtrl149){
2120 addr = F54ControlBase + F54Ctrl149Offset;
2121 Read8BitRegisters(addr, &data, 1);
2122 data = data & 0xFE;
2123 Write8BitRegisters(addr, &data, 1);
2124 }
2125
2126 // Turn off 0D CBC.
2127 if (bHaveF54Ctrl57){
2128 addr = F54ControlBase + F54Ctrl57Offset;
2129 Read8BitRegisters(addr, &data, 1);
2130 //ata = data & 0xEF;
2131 data = 0;
2132 Write8BitRegisters(addr, &data, 1);
2133 }
2134
2135 // Turn off SignalClarity. ForceUpdate is required for the change to be effective
2136 if (SignalClarityOn){
2137 addr = F54ControlBase + F54Ctrl41Offset;
2138 Read8BitRegisters(addr, &data, 1);
2139 data = data | 0x01;
2140 Write8BitRegisters(addr, &data, 1);
2141 }
2142
2143 // Apply ForceUpdate.
2144 Read8BitRegisters(F54CommandBase, &data, 1);
2145 printk("s3528 Apply ForceUpdate => F54CommandBase\n");
2146 data = data | 0x04;
2147 Write8BitRegisters(F54CommandBase, &data, 1);
2148 printk("s3528 Apply ForceUpdate=>F54CommandBase\n");
2149 // Wait complete
2150 count = 0;
2151 do {
2152 Read8BitRegisters(F54CommandBase, &data, 1);
2153 msleep(1);
2154 count++;
2155 } while (data != 0x00 && (count < DefaultTimeout));
2156
2157 if(count >= DefaultTimeout) {
2158 outbuf += sprintf(f54_wlog_buf+outbuf, "Timeout -- ForceUpdate can not complete\n");
2159 //TOUCH_INFO_MSG("Timeout -- ForceUpdate can not complete\n");
2160 Reset();
2161 return false;
2162 }
2163
2164 // Apply ForceCal.
2165 Read8BitRegisters(F54CommandBase, &data, 1);
2166 data = data | 0x02;
2167 Write8BitRegisters(F54CommandBase, &data, 1);
2168
2169 // Wait complete
2170 count = 0;
2171 do {
2172 Read8BitRegisters(F54CommandBase, &data, 1);
2173 msleep(1);
2174 count++;
2175 } while (data != 0x00 && (count < DefaultTimeout));
2176
2177 if(count >= DefaultTimeout){
2178 outbuf += sprintf(f54_wlog_buf+outbuf, "Timeout -- ForceCal can not complete\n");
2179 //TOUCH_INFO_MSG("Timeout -- ForceCal can not complete\n");
2180 Reset();
2181 return false;
2182 }
2183
2184 return true;
2185}
2186
2187int diffnode(unsigned short *ImagepTest)
2188{
2189
2190 int i = 0;
2191 int k = 0;
2192 unsigned char data;
2193
2194 if (!bHaveF54) {
2195 TOUCH_INFO_MSG("not bHaveF54\n");
2196 return -1;
2197 }
2198 if (!switchPage(0x01)) {
2199 TOUCH_INFO_MSG("not switchPage(0x01)\n");
2200 return -1;
2201 }
2202
2203 if (TestPreparation()){
2204
2205 //memcpy(LowerImageLimit, LowerImage, sizeof(LowerImageLimit));
2206 //memcpy(UpperImageLimit, UpperImage, sizeof(UpperImageLimit));
2207 data = 20;//rawdata mode
2208 Write8BitRegisters(F54DataBase, &data, 1);
2209 data = 0x01;
2210 Write8BitRegisters(F54CommandBase, &data, 1);
2211 count = 0;
2212 do {
2213 Read8BitRegisters(F54CommandBase, &data, 1);
2214 msleep(1);
2215 count++;
2216 } while (data != 0x00 && (count < DefaultTimeout));
2217 if(count >= DefaultTimeout) {
2218 TOUCH_INFO_MSG("Timeout -- Not supported Report Type in FW\n");
2219 Reset();
2220 return -1;
2221 }
2222
2223 Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), &Data[0], MaxArrayLength);
2224
2225 for (i = 0; i < (int)TxChannelCount * (int)RxChannelCount; i++) {
2226 ImagepTest[i] = ((short)Data[k] | (short)Data[k + 1] << 8);
2227 k = k + 2;
2228 }
2229 //Reset Device
2230 Reset();
2231 TOUCH_INFO_MSG("diff_node success\n");
2232 return 0;
2233
2234 } else {
2235 return -1;
2236 }
2237
2238}
2239
2240// The following funtion illustrates the steps in getting a full raw image report (report #20) by Function $54.
2241int ImageTest(int mode, char *buf)
2242{
2243 unsigned char data;
2244
2245 if (TestPreparation()){
2246 //memcpy(LowerImageLimit, LowerImage, sizeof(LowerImageLimit));
2247 //memcpy(UpperImageLimit, UpperImage, sizeof(UpperImageLimit));
2248
2249 // Assign report type for Full Raw Image
2250
2251 data = 20;//raw capacitance mode
2252 TOUCH_INFO_MSG("[Touch][%s] raw capacitance mode!\n", __FUNCTION__);
2253
2254 Write8BitRegisters(F54DataBase, &data, 1);
2255 //mode setting
2256 do_gettimeofday(&t_interval[STARTTIME]);
2257
2258 if(mode == 0)
2259 data = 'a';//rawdata store mode
2260 else
2261 data = 'l';//rawdata display mode
2262
2263 return ReadReport(data, buf);
2264
2265 } else {
2266 return -1;
2267 }
2268}
2269
2270int DeltaTest(char *buf)
2271{
2272 unsigned char data;
2273
2274 //memcpy(LowerImageLimit, LowerImage, sizeof(LowerImageLimit));
2275 //memcpy(UpperImageLimit, UpperImage, sizeof(UpperImageLimit));
2276
2277 // Assign report type for Full Raw Image
2278 data = 0x02;//delta mode
2279 TOUCH_INFO_MSG("[Touch][%s] delta mode!\n", __FUNCTION__);
2280
2281 Write8BitRegisters(F54DataBase, &data, 1);
2282
2283 do_gettimeofday(&t_interval[STARTTIME]);
2284
2285 data = 'l';//rawdata display mode
2286
2287 return ReadReport(data, buf);
2288
2289}
2290
2291
2292int NoiseDeltaTest(char *buf)
2293{
2294 unsigned char data;
2295
2296 memset(NoiseDeltaMin, 0, TRX_MAX * TRX_MAX * sizeof(short));
2297 memset(NoiseDeltaMax, 0, TRX_MAX * TRX_MAX * sizeof(short));
2298
2299 TOUCH_INFO_MSG("[Touch][%s] Noise Delta mode!\n", __FUNCTION__);
2300
2301 // Assign report type for Full Raw Image
2302 data = 0x02;//delta mode
2303
2304 Write8BitRegisters(F54DataBase, &data, 1);
2305
2306 data = 'm';//rawdata display mode
2307
2308 return ReadReport(data, buf);
2309
2310}
2311
2312// The following funtion illustrates the steps in getting a sensor speed test report (report #22) by Function $54.
2313int SensorSpeed(char *buf)
2314{
2315 unsigned char data;
2316
2317 memcpy(SensorSpeedLowerImageLimit, SensorSpeedLowerImage, sizeof(SensorSpeedLowerImageLimit));
2318 memcpy(SensorSpeedUpperImageLimit, SensorSpeedUpperImage, sizeof(SensorSpeedUpperImageLimit));
2319
2320 // Assign report type for Sensor Speed Test
2321 data = 22;
2322 Write8BitRegisters(F54DataBase, &data, 1);
2323
2324 do_gettimeofday(&t_interval[STARTTIME]);
2325
2326 data = 'c';
2327 return ReadReport(data, buf);
2328
2329}
2330
2331// The following funtion illustrates the steps in getting a ADC Range report (report #23) by Function $54.
2332int ADCRange(char *buf)
2333{
2334 unsigned char data = 0;
2335
2336 memcpy(ADCLowerImageLimit, ADCLowerImage, sizeof(ADCLowerImageLimit));
2337 memcpy(ADCUpperImageLimit, ADCUpperImage, sizeof(ADCUpperImageLimit));
2338
2339 Read8BitRegisters((F54ControlBase + F54Ctrl41Offset), &data, 1);
2340 if (data & 0x01)
2341 SignalClarityOn = false;
2342 else SignalClarityOn = true;
2343
2344 // Assign report type for ADC Range report
2345 data = 23;
2346 Write8BitRegisters(F54DataBase, &data, 1);
2347
2348 do_gettimeofday(&t_interval[STARTTIME]);
2349 //startTime = GetTickCount();
2350
2351 data = 'b';
2352 return ReadReport(data, buf);
2353}
2354
2355void AbsADCRange(char *buf)
2356{
2357 unsigned char data;
2358
2359 if (TestPreparation()){
2360 // Assign report type for Abs Sensing ADC Range report
2361 data = 42;
2362 Write8BitRegisters(F54DataBase, &data, 1);
2363
2364 do_gettimeofday(&t_interval[STARTTIME]);
2365 //startTime = GetTickCount();
2366
2367 data = 'i';
2368 ReadReport(data, buf);
2369 }
2370}
2371// report type 40
2372int AbsDelta(char *buf)
2373{
2374 unsigned char data;
2375
2376 //--switchPage(0x01);
2377
2378 // Assign report type for Abs Sensing Delta Capacitance report
2379 data = 40;
2380 Write8BitRegisters(F54DataBase, &data, 1);
2381
2382 do_gettimeofday(&t_interval[STARTTIME]);
2383 //startTime = GetTickCount();
2384
2385 data = 'j';
2386 return ReadReport(data, buf);
2387}
2388// report type 38
2389int AbsRaw(int mode, char *buf)
2390{
2391 unsigned char data;
2392
2393 //switchPage(0x01);
2394 if (bHaveCtrl98) {
2395 Read8BitRegisters((F54ControlBase+F54Ctrl98Offset), &Data[0], 6);
2396
2397 AbsRxShortLimit = AbsRawRef[Data[0]] * 275/100;//AbsRx Low Reference
2398 AbsTxShortLimit = AbsRawRef[Data[5]] * 275/100;//AbsTx Low Reference
2399 AbsTxOpenLimit = AbsRawRef[Data[5]] * 75/100;//AbsTx Low Reference
2400 }
2401
2402 data = 38;
2403 Write8BitRegisters(F54DataBase, &data, 1);
2404
2405 do_gettimeofday(&t_interval[STARTTIME]);
2406 //startTime = GetTickCount();
2407
2408 if (mode == 1)
2409 data = 'n';//Abs Sensing Short Test mode
2410 else if (mode == 2)
2411 data = 'o';//Abs Sensing Open Test mode
2412 else
2413 data = 'k';//Abs Sensing Raw Test mode
2414
2415 return ReadReport(data, buf);
2416}
2417
2418// The following funtion illustrates the steps in getting a TRex-Opens(No sensor) report (report #24) by Function $54.
2419void TRexOpenTest(char *buf)
2420{
2421 unsigned char data;
2422
2423 //fprintf(stderr, "Press any key to continue after you have lowered the bar.\n");
2424 //_getch();
2425
2426 if (TestPreparation()){
2427 // Assign report type for TRex Open Test
2428 data = 24;
2429 Write8BitRegisters(F54DataBase, &data, 1);
2430
2431 data = 'd';
2432 ReadReport(data, buf);
2433 }
2434}
2435
2436// The following funtion illustrates the steps in getting a TRex-to-GND(No sensor) report (report #25) by Function $54.
2437int TRexGroundTest(char *buf)
2438{
2439 unsigned char data;
2440
2441 if (TestPreparation()){
2442 // Assign report type for TRex Ground Test
2443 data = 25;
2444 Write8BitRegisters(F54DataBase, &data, 1);
2445
2446 data = 'e';
2447 return ReadReport(data, buf);
2448 } else {
2449 return -1;
2450 }
2451}
2452
2453// The following funtion illustrates the steps in getting a TRex-TRex short(No sensor) report (report #26) by Function $54.
2454int TRexShortTest(char *buf)
2455{
2456
2457 unsigned char data;
2458
2459 if (TestPreparation()){
2460 // Assign report type for TRex Short Test
2461 data = 26;
2462 Write8BitRegisters(F54DataBase, &data, 1);
2463 data = 'f';
2464 return ReadReport(data, buf);
2465 } else {
2466 return -1;
2467 }
2468}
2469
2470// This test is to retreive the high resistance report, report type #4.
2471int HighResistanceTest(char *buf)
2472{
2473 unsigned char data;
2474
2475 if (TestPreparation()){
2476
2477 // Assign report type for High Resistance report
2478 data = 4;
2479 Write8BitRegisters(F54DataBase, &data, 1);
2480 data = 'g';
2481 return ReadReport(data, buf);
2482 } else {
2483 return -1;
2484 }
2485}
2486
2487// This test is to retreive the maximum and minimum pixel report, report type #13.
2488void MaxMinTest(char *buf)
2489{
2490 unsigned char data;
2491
2492 if (TestPreparation()){
2493 // Assign report type for Max Min report
2494 data = 13;
2495 Write8BitRegisters(F54DataBase, &data, 1);
2496
2497 data = 'h';
2498 ReadReport(data, buf);
2499 }
2500}
2501
2502void CheckCrash(char *rst, int min_caps_value)
2503{
2504 int i = 0;
2505 int j = 0;
2506 int k = 0;
2507 int node_crack_count = 0;
2508 int rx_crack_count = 0;
2509 int row_crack_count = 0;
2510 unsigned char cmd;
2511
2512 if (TestPreparation() == false){
2513 TOUCH_INFO_MSG("TestPreparation failed\n");
2514 goto error;
2515 }
2516
2517 cmd = 20;
2518 DO_SAFE(Write8BitRegisters(F54DataBase, &cmd, 1), error);
2519
2520 cmd = 0x01;
2521 DO_SAFE(Write8BitRegisters(F54CommandBase, &cmd, 1), error);
2522
2523 count = 0;
2524 do {
2525 DO_SAFE(Read8BitRegisters(F54CommandBase, &cmd, 1), error);
2526 msleep(1);
2527 count++;
2528 } while (cmd != 0x00 && (count < DefaultTimeout));
2529
2530 DO_SAFE(Read8BitRegisters((F54DataBase+REPORT_DATA_OFFEST), Data, MaxArrayLength), error);
2531
2532 for (i = 0; i < (int)TxChannelCount; i++) {
2533 for (j = 0; j < (int)RxChannelCount; j++) {
2534 ImagepF[i][j] = ((short)Data[k] | (short)Data[k+1] << 8);
2535
2536 if ((ImagepF[i][j] < LowerImageLimit[i][j]) || (ImagepF[i][j] > UpperImageLimit[i][j])) {
2537 if (ImagepF[i][j] < min_caps_value) {
2538 rx_crack_count++;
2539 node_crack_count++;
2540 }
2541 else {
2542 row_crack_count = 0;
2543 }
2544
2545 if (F12_2DRxCount <= rx_crack_count)
2546 row_crack_count++;
2547
2548 if (5 < row_crack_count || (F12_2DTxCount*F12_2DRxCount*40/100) < node_crack_count) {
2549 sprintf(rst, "%d", 1);
2550 return;
2551 }
2552 }
2553
2554 k += 2;
2555 }
2556
2557 rx_crack_count = 0;
2558 }
2559
2560 sprintf(rst, "%d", 0);
2561 TOUCH_INFO_MSG("Tx [%d] Rx [%d] node_crack_count %d, row_crack_count %d\n",
2562 i,
2563 j,
2564 node_crack_count,
2565 row_crack_count);
2566
2567 return;
2568error:
2569 sprintf(rst, "%d", 0);
2570 printk("[s3528]winodw crack check fail\n");
2571}
2572
2573void SCAN_PDT(void)
2574{
2575 int i;
2576
2577 for (i = 0; i < scanMaxPageCount ;i++)
2578 {
2579 if (switchPage(i))
2580 RunQueries();
2581 }
2582}
2583
2584// Main entry point for the application
2585int F54Test(int input, int mode, char *buf)
2586 //int _tmain(int argc, _TCHAR* argv[])
2587{
2588 printk("[s3528][F54TEST] input = %d, mode = %d \n",input,mode );
2589
2590 int ret = 0;
2591 unsigned char data;
2592 //if (PowerOnSensor())
2593 //{
2594 // fatal("Error powering on sensor.\n");
2595 //}
2596
2597 // These four function calls are to scan the Page Description Table (PDT)
2598 // Function $01, $11 and $34 are on page 0
2599 // Function $54 is on page 1
2600 // Function $55 is on Page ?
2601 // Scan up to Page 4
2602 //for (int i = 0; i < scanMaxPageCount ;i++)
2603 //{
2604 // if (switchPage(i))
2605 // RunQueries();
2606 //}
2607
2608 // Application should exit with the absence of Function $54
2609// if (!bHaveF54)
2610// return -1;
2611 //exit(0);
2612 //LoadTestLimits();
2613 /*
2614 while (1){
2615 printf("\nPress these keys for tests:\n");
2616 printf(" a ) - Full Raw Capacitance Test\n");
2617 printf(" b ) - ADC Range Test\n");
2618 printf(" c ) - Sensor Speed Test\n");
2619 printf(" d ) - TRex Open Test\n");
2620 printf(" e ) - TRex Gnd Test\n");
2621 printf(" f ) - TRx-to-TRx and TRx-to-Vdd shorts\n");
2622 printf(" g ) - High Resistance Test\n");
2623 printf(" h ) - Full Raw Capacitance Max/Min Test\n");
2624 printf(" i ) - Abs Sensing ADC Range Test\n");
2625 printf(" j ) - Abs Sensing Delta Capacitance\n");
2626 printf(" k ) - Abs Sensing Raw Capcitance Test\n");
2627 printf("---------------------------------------------------------------");
2628 printf("\n z ) - Version\n");
2629 printf("\nPress any other key to exit.\n");
2630 input = _getch();
2631 */
2632 if (!switchPage(0x01))
2633 return false;
2634
2635 data = 0x00;
2636 Write8BitRegisters(F54DataBase+1, &data, 1);
2637 Write8BitRegisters(F54DataBase+2, &data, 1);
2638
2639 outbuf = 0;
2640 out_buf = 0;
2641 memset(f54_wlog_buf, 0, sizeof(f54_wlog_buf));
2642 memset(wlog_buf, 0, sizeof(wlog_buf));
2643
2644 switch(input){
2645 case 'a':
2646 outbuf = sprintf(f54_wlog_buf, "a - Full Raw Capacitance Test\n");
2647 ret = ImageTest(mode, buf);
2648 break;
2649 case 'b':
2650 out_buf = sprintf(wlog_buf, "b - ADC Range Test\n");
2651 ret = ADCRange(buf);
2652 break;
2653 case 'c':
2654 out_buf = sprintf(wlog_buf, "c - Sensor Speed Test\n");
2655 ret = SensorSpeed(buf);
2656 break;
2657 case 'd':
2658 outbuf = sprintf(f54_wlog_buf, "d - TRex Open Test\n");
2659 TRexOpenTest(buf);
2660 break;
2661 case 'e'://B2Lite
2662 outbuf = sprintf(f54_wlog_buf, "e - TRex Gnd Test\n");
2663 ret = TRexGroundTest(buf);
2664 break;
2665 case 'f'://B2Lite
2666 outbuf = sprintf(f54_wlog_buf, "f - TRex Short Test\n");
2667 ret = TRexShortTest(buf);
2668 break;
2669 case 'g'://B2Lite
2670 outbuf = sprintf(f54_wlog_buf, "g - High Resistance Test\n");
2671 ret = HighResistanceTest(buf);
2672 break;
2673 case 'h':
2674 outbuf = sprintf(f54_wlog_buf, "h - Full Raw Capacitance Max/Min Test\n");
2675 MaxMinTest(buf);
2676 break;
2677 case 'i':
2678 outbuf = sprintf(f54_wlog_buf, "i - Abs Sensing ADC Range Test\n");
2679 AbsADCRange(buf);
2680 break;
2681 case 'j':
2682 outbuf = sprintf(f54_wlog_buf, "j - Abs Sensing Delta Capacitance\n");
2683 ret = AbsDelta(buf);
2684 break;
2685 case 'k':
2686 outbuf = sprintf(f54_wlog_buf, "k - Abs Sensing Raw Capcitance Test\n");
2687 AbsRaw(mode, buf);
2688 break;
2689 case 'l':
2690 CheckCrash(buf, mode);
2691 break;
2692 case 'm':
2693 ret = DeltaTest(buf);
2694 break;
2695 case 'n':
2696 outbuf = sprintf(f54_wlog_buf, "n - Abs Sensing Raw Short Capcitance Test\n");
2697 ret = AbsRaw(mode,buf);
2698 break;
2699 case 'o':
2700 outbuf = sprintf(f54_wlog_buf, "k - Abs Sensing Raw Open Capcitance Test\n");
2701 ret = AbsRaw(mode,buf);
2702 break;
2703 case 'x'://B2Lite
2704 out_buf = sprintf(wlog_buf, "x - Noise Delta Test\n");
2705 ret = NoiseDeltaTest(buf);
2706 break;
2707 case 'z':
2708 TOUCH_INFO_MSG("Version: %s\n", VERSION);
2709 break;
2710 default:
2711 return -1;
2712 //PowerOffSensor();
2713 //exit(0);
2714 }
2715 return ret;
2716}
kernel source for telekom puls (alcatel/mediatek)