summaryrefslogtreecommitdiffstats
path: root/drivers/input/touchscreen/rm31080a_ctrl.c
diff options
context:
space:
mode:
authorDavid Jung <djung@nvidia.com>2012-09-14 22:31:11 -0400
committerDavid Pu <dpu@nvidia.com>2017-07-27 19:09:19 -0400
commitbdb133feba7db62627a26195f08f0a443ce07633 (patch)
treeb66f0b9e7f0ba9ead3b2adcb61996697356e15f0 /drivers/input/touchscreen/rm31080a_ctrl.c
parent46b55d7f872f86c920de6852b5c2a57d91894b1d (diff)
input: touch: raydium: Update Raydium direct touch driver.
Update Raydium files to support 5 inch touch sensor from Wintech. Also adds 5-inch, 10-inch panel support. Bug 1030747 Reviewed-on: http://git-master/r/133031 (cherry picked from commit 9033bee975273d0dfcc0d9cc8a8c7b97b2e77069) Change-Id: I846b9d0faba31072113e030aa7102b34074c2585 Signed-off-by: David Jung <djung@nvidia.com> Signed-off-by: Deepak Nibade <dnibade@nvidia.com> Reviewed-on: http://git-master/r/143114 Reviewed-by: Rohan Somvanshi <rsomvanshi@nvidia.com> Tested-by: Rohan Somvanshi <rsomvanshi@nvidia.com> Rebase-Id: R84f2852e4a5a704feecd90e9b23195ed3fc19d1a
Diffstat (limited to 'drivers/input/touchscreen/rm31080a_ctrl.c')
-rw-r--r--drivers/input/touchscreen/rm31080a_ctrl.c1228
1 files changed, 1228 insertions, 0 deletions
diff --git a/drivers/input/touchscreen/rm31080a_ctrl.c b/drivers/input/touchscreen/rm31080a_ctrl.c
new file mode 100644
index 000000000..516d2bd78
--- /dev/null
+++ b/drivers/input/touchscreen/rm31080a_ctrl.c
@@ -0,0 +1,1228 @@
1/*
2 * Raydium RM31080 touchscreen driver
3 *
4 * Copyright (C) 2012 Raydium Semiconductor Corporation
5 * Copyright (C) 2012 NVIDIA Corporation
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
11 *
12 */
13//=============================================================================
14//INCLUDED FILES
15//=============================================================================
16#include <linux/device.h>
17#include <asm/uaccess.h> // copy_to_user(),
18#include <linux/delay.h>
19#include <linux/module.h> // Module definition
20
21#include <linux/spi/rm31080a_ts.h>
22#include <linux/spi/rm31080a_ctrl.h>
23//=============================================================================
24//DEFINITIONS
25//=============================================================================
26#define RM31080_RAW_DATA_LENGTH 2048
27#define MAX_AVERAGE_TIMES 128
28//=============================================================================
29//STRUCTURE DECLARATION
30//=============================================================================
31
32//=============================================================================
33//GLOBAL VARIABLES DECLARATION
34//=============================================================================
35struct rm31080a_ctrl_para g_stCtrl;
36
37//Marty added
38static u8 g_pbBaseline[RM31080_RAW_DATA_LENGTH]; // Noise_Detector
39#if ENABLE_NEW_NOISE_MODE
40static u8 g_pbAnalogBaseline[RM31080_RAW_DATA_LENGTH]; // Noise_Detector
41#endif
42signed int g_noiseLevel[3]; // Noise_Detector
43unsigned short g_noisechecktimes; // Noise_Detector
44
45//Marty added
46s8 g_bAverageBuf[MAX_AVERAGE_TIMES][RM31080_RAW_DATA_LENGTH];
47s8 g_bMFBlockMax[MAX_AVERAGE_TIMES];
48s8 g_bMFBlockMin[MAX_AVERAGE_TIMES];
49u8 g_bMFCounter[MAX_AVERAGE_TIMES];
50s8 g_bRawData[MAX_AVERAGE_TIMES][16];
51u8 g_bfFirstAverage;
52//Marty added
53unsigned short u16ShowCnt = 0;
54signed char bDTImage[60][8];
55unsigned char bfSign[60];
56
57//=============================================================================
58//FUNCTION DECLARATION
59//=============================================================================
60
61//=============================================================================
62// Description:
63// Control functions for Touch IC
64// Input:
65//
66// Output:
67//
68//=============================================================================
69
70int rm31080_ctrl_clear_int(void)
71{
72 u8 flag;
73#if ENABLE_T007B1_SETTING
74 if (g_stCtrl.bICVersion == T007_VERSION_B)
75 return rm31080_spi_byte_read(RM31080B1_REG_BANK0_02H, &flag);
76 else
77#endif
78 return rm31080_spi_byte_read(RM31080_REG_F2, &flag);
79}
80
81int rm31080_ctrl_scan_start(void)
82{
83 return rm31080_spi_byte_write(RM31080_REG_11, 0x17);
84}
85
86void rm31080_ctrl_wait_for_scan_finish(void)
87{
88 u8 u8reg11;
89 int i;
90 //50ms = 20Hz
91 for (i = 0; i < 50; i++) {
92 rm31080_spi_byte_read(RM31080_REG_11, &u8reg11);
93 if (u8reg11 & 0x01)
94 msleep(1);
95 else
96 break;
97 }
98}
99
100//=============================================================================
101// Description:
102//
103// Input:
104// N/A
105// Output:
106// N/A
107//=============================================================================
108//Marty added
109int rm31080_soft_average(signed char *pSource)
110{
111 static u8 u8AverageIndex = 0;
112 static u8 u8AverageIndexMinor = 0;
113 static u8 u8StartAverage = 0;
114 u16 i, j, k;
115 s16 s16Sum;
116 u8 bMaxBlockId;
117 u8 TestA, TestB, TestC;
118 s8 bMax, bMin;
119 s8 bResult0, bResult1, bResult2;
120 u8 bRes;
121 u8 bAverageTimes;
122 static u8 bAverageRatio = 0;
123
124 bResult1 = 0;
125 bResult2 = 0;
126 bAverageTimes = g_stCtrl.bNoiseRepeatTimes;
127
128 if (g_stCtrl.bfNoisePreHold) {
129 u8AverageIndex = 0;
130 u8AverageIndexMinor = 0;
131 bAverageRatio = 0;
132 g_bfFirstAverage = 0;
133
134 return 0;
135 }
136#if ENABLE_NEW_NOISE_MODE
137 if (!((g_stCtrl.bfNoiseMode & 0x01) || g_stCtrl.bfNoiseModeDetector))
138#else
139 if (!(g_stCtrl.bfNoiseMode || g_stCtrl.bfNoiseModeDetector))
140#endif
141 {
142 u8AverageIndex = 0;
143 u8AverageIndexMinor = 0;
144 bAverageRatio = 0;
145 g_bfFirstAverage = 0;
146 if (g_stCtrl.bfExitNoiseMode) {
147 g_stCtrl.bfExitNoiseMode = 0;
148 return 0;
149 } else {
150 return 1;
151 }
152 }
153
154 for (i = 0; i < g_stCtrl.u16DataLength; i++) //RM31080_RAW_DATA_LENGTH =1530
155 {
156 g_bAverageBuf[u8AverageIndex][i] = g_pbBaseline[i] - pSource[i];
157 }
158 u8AverageIndex++;
159 if (g_stCtrl.bNoiseRepeatTimes > g_stCtrl.bNoisePipelineBase)
160 u8AverageIndexMinor++;
161
162 if (g_stCtrl.bNoiseRepeatTimes <= g_stCtrl.bNoisePipelineBase) {
163 bAverageTimes = g_stCtrl.bNoiseRepeatTimes;
164 if (u8AverageIndex == g_stCtrl.bNoiseRepeatTimes) {
165 u8StartAverage = 1;
166 u8AverageIndex = 0;
167 }
168#if 1
169 else
170 u8StartAverage = 0;
171#endif
172 }
173 else
174 {
175 if (!g_bfFirstAverage)
176 {
177 if (u8AverageIndex < g_stCtrl.bNoiseRepeatTimes)
178 {
179 if (u8AverageIndexMinor == g_stCtrl.bNoisePipelineBase) {
180 u8StartAverage = 1;
181 u8AverageIndexMinor = 0;
182 bAverageRatio++;
183 bAverageTimes = g_stCtrl.bNoisePipelineBase * bAverageRatio;
184 }
185 else
186 u8StartAverage = 0;
187 }
188 else
189 {
190 if (u8AverageIndex == g_stCtrl.bNoiseRepeatTimes)
191 {
192 u8AverageIndex = 0;
193 if (u8AverageIndexMinor == g_stCtrl.bNoisePipelineBase)
194 {
195 u8StartAverage = 1;
196 u8AverageIndexMinor = 0;
197 bAverageRatio++;
198 bAverageTimes = g_stCtrl.bNoisePipelineBase * bAverageRatio;
199 g_bfFirstAverage = 1;
200 }
201 else
202 {
203 bAverageTimes = g_stCtrl.bNoiseRepeatTimes;
204 g_bfFirstAverage = 1;
205 u8StartAverage = 0;
206 }
207 }
208 }
209 }
210 else
211 {
212 bAverageTimes = g_stCtrl.bNoiseRepeatTimes;
213 if (u8AverageIndexMinor == g_stCtrl.bNoisePipelineBase)
214 {
215 u8StartAverage = 1;
216 u8AverageIndexMinor = 0;
217 }
218 else
219 u8StartAverage = 0;
220
221 if (u8AverageIndex == g_stCtrl.bNoiseRepeatTimes)
222 {
223 u8AverageIndex = 0;
224 }
225 }
226 }
227
228 if (u8StartAverage) {
229 for (i = 0; i < g_stCtrl.u16DataLength; i++) {
230 if (g_stCtrl.bfMediumFilter & 0x01) {
231 for (j = 0; j < g_stCtrl.bMFBlockNumber; j++) {
232 g_bMFCounter[j] = 0;
233 }
234 for (j = 0; j < bAverageTimes; j++) {
235 for (k = 0; k < g_stCtrl.bMFBlockNumber; k++) {
236 if (g_bAverageBuf[j][i] <= g_bMFBlockMax[k] && g_bAverageBuf[j][i] >= g_bMFBlockMin[k]) {
237 g_bRawData[g_bMFCounter[k]][k] = g_bAverageBuf[j][i];
238 g_bMFCounter[k]++;
239 break;
240 }
241 }
242 }
243 bMaxBlockId = 0;
244 for (j = 0; j < g_stCtrl.bMFBlockNumber; j++) {
245 if (g_bMFCounter[j] > g_bMFCounter[bMaxBlockId]) {
246 bMaxBlockId = j;
247 } else if (g_bMFCounter[j] == g_bMFCounter[bMaxBlockId]) {
248 if (j > g_stCtrl.bMFBlockNumber / 2)
249 TestA = j - g_stCtrl.bMFBlockNumber / 2;
250 else
251 TestA = g_stCtrl.bMFBlockNumber / 2 - j;
252 if (bMaxBlockId > g_stCtrl.bMFBlockNumber / 2)
253 TestB = bMaxBlockId - g_stCtrl.bMFBlockNumber / 2;
254 else
255 TestB = g_stCtrl.bMFBlockNumber / 2 - bMaxBlockId;
256 if (TestA < TestB) {
257 bMaxBlockId = j;
258 }
259 }
260 }
261 //printk("ID = %d, Max Counter ID = %d, Count = %d\n", i, bMaxBlockId, g_bMFCounter[bMaxBlockId]);
262 s16Sum = 0;
263 for (j = 0; j < g_bMFCounter[bMaxBlockId]; j++) {
264 s16Sum += g_bRawData[j][bMaxBlockId];
265 }
266 if (g_bMFCounter[bMaxBlockId] == 0) {
267 bResult1 = 0;
268 } else {
269 bResult1 = (s16Sum / g_bMFCounter[bMaxBlockId]);
270 //if (g_stCtrl.bfNoiseDetector)
271 //{
272 // bResult1 = (s16)bResult1 * 4 / 5;
273 //}
274 }
275 }
276
277 if (g_stCtrl.bfMediumFilter & 0x02) {
278 bMax = -128;
279 bMin = 127;
280 for (j = 0; j < bAverageTimes; j++) {
281 if (g_bAverageBuf[j][i] > bMax)
282 bMax = g_bAverageBuf[j][i];
283 if (g_bAverageBuf[j][i] < bMin)
284 bMin = g_bAverageBuf[j][i];
285 }
286 bResult2 = (bMax + bMin) / 2;
287 //if (g_stCtrl.bfNoiseDetector)
288 //{
289 // bResult2 = (s16)bResult2 * 4 / 5;
290 //}
291
292 }
293
294 s16Sum = 0;
295 for (j = 0; j < bAverageTimes; j++) {
296 bRes = i % (g_stCtrl.bChannelNumberX + 2 + g_stCtrl.bADCNumber);
297 if (bRes > 0 && bRes < 4) {
298 if (g_bAverageBuf[j][i] < g_stCtrl.bNoiseThresholdLowMax && g_bAverageBuf[j][i] > g_stCtrl.bNoiseThresholdLowMin)
299 g_bAverageBuf[j][i] = 0;
300 else if (g_bAverageBuf[j][i] > 40)
301 g_bAverageBuf[j][i] = 40;
302 else if (g_bAverageBuf[j][i] < -40)
303 g_bAverageBuf[j][i] = -40;
304 } else {
305 if (g_bAverageBuf[j][i] < g_stCtrl.bNoiseThresholdLowMax && g_bAverageBuf[j][i] > g_stCtrl.bNoiseThresholdLowMin)
306 g_bAverageBuf[j][i] = 0;
307 else if (g_bAverageBuf[j][i] > g_stCtrl.bNoiseThresholdMax)
308 g_bAverageBuf[j][i] = g_stCtrl.bNoiseThresholdMax;
309 else if (g_bAverageBuf[j][i] < g_stCtrl.bNoiseThresholdMin)
310 g_bAverageBuf[j][i] = g_stCtrl.bNoiseThresholdMin;
311 }
312
313 s16Sum += g_bAverageBuf[j][i];
314 }
315 bResult0 = (s16Sum / g_stCtrl.bNoiseRepeatTimes); // + 0x80;
316 //if (g_stCtrl.bfNoiseDetector)
317 //{
318 // bResult0 = (s16)bResult0 * 4 / 5;
319 //}
320
321 if (g_stCtrl.bfMediumFilter & 0x01) {
322 if (bResult0 > 0)
323 TestA = bResult0;
324 else
325 TestA = -bResult0;
326 if (bResult1 > 0)
327 TestB = bResult1;
328 else
329 TestB = -bResult1;
330 if (TestA < TestB)
331 pSource[i] = g_pbBaseline[i] - bResult0;
332 else
333 pSource[i] = g_pbBaseline[i] - bResult1;
334 } else if (g_stCtrl.bfMediumFilter & 0x02) {
335 if (bResult0 > 0)
336 TestA = bResult0;
337 else
338 TestA = -bResult0;
339 if (bResult2 > 0)
340 TestC = bResult2;
341 else
342 TestC = -bResult2;
343 if (TestA < TestC)
344 pSource[i] = g_pbBaseline[i] - bResult0;
345 else
346 pSource[i] = g_pbBaseline[i] - bResult2;
347 } else if (g_stCtrl.bfMediumFilter & 0x03) {
348 if (bResult0 > 0)
349 TestA = bResult0;
350 else
351 TestA = -bResult0;
352 if (bResult1 > 0)
353 TestB = bResult1;
354 else
355 TestB = -bResult1;
356 if (bResult2 > 0)
357 TestC = bResult2;
358 else
359 TestC = -bResult2;
360 if ((TestA < TestB) && (TestA < TestC))
361 pSource[i] = g_pbBaseline[i] - bResult0;
362 else if ((TestB < TestA) && (TestB < TestC))
363 pSource[i] = g_pbBaseline[i] - bResult1;
364 else if ((TestC < TestA) && (TestC < TestB))
365 pSource[i] = g_pbBaseline[i] - bResult2;
366
367 } else {
368 pSource[i] = g_pbBaseline[i] - bResult0;
369 }
370 }
371
372 return 1;
373 }
374 return 0;
375}
376
377//=============================================================================
378// Description:
379//
380// Input:
381// N/A
382// Output:
383// N/A
384//=============================================================================
385void rm_set_repeat_times(u8 u8Times)
386{
387 u8 bReg1_1Fh = 0x00;
388 u8 u8Reg = 0x00;
389#if ENABLE_T007B1_SETTING
390 if (g_stCtrl.bICVersion == T007_VERSION_B)
391 {
392 u8Reg = g_stCtrl.bSenseNumber - 1;
393 rm31080_spi_byte_write(0x0A, u8Reg&0x0F);
394 rm31080_spi_byte_write(0x0E, u8Times&0x1F);
395 if (g_stCtrl.bfADFC)
396 bReg1_1Fh |= ADFC;
397
398 if (g_stCtrl.bfTHMode)
399 bReg1_1Fh |= FILTER_THRESHOLD_MODE;
400 else
401 bReg1_1Fh &= ~FILTER_NONTHRESHOLD_MODE;
402 //bReg1_1Fh |= FILTER_NONTHRESHOLD_MODE;
403
404 if (u8Times != REPEAT_1)
405 bReg1_1Fh |= 0x44; //Marty 20120820
406
407 rm31080_spi_byte_write(RM31080_REG_1F, bReg1_1Fh);
408 }
409 else
410#endif
411 {
412 u8Reg = ((g_stCtrl.bSenseNumber - 1) << 3) | u8Times;
413
414 rm31080_spi_byte_write(RM31080_REG_0E, u8Reg);
415 if (g_stCtrl.bfADFC)
416 bReg1_1Fh |= ADFC;
417
418 if (g_stCtrl.bfTHMode)
419 bReg1_1Fh |= FILTER_THRESHOLD_MODE;
420 else
421 bReg1_1Fh &= ~FILTER_NONTHRESHOLD_MODE;
422 //bReg1_1Fh |= FILTER_NONTHRESHOLD_MODE;
423
424 if (u8Times != REPEAT_1)
425 bReg1_1Fh |= (u8Times + 3);
426
427 rm31080_spi_byte_write(RM31080_REG_1F, bReg1_1Fh);
428 }
429}
430
431//=============================================================================
432// Description:
433//
434// Input:
435// N/A
436// Output:
437// N/A
438//=============================================================================
439NOISE_DETECTOR_RET_t rm_noise_detect(signed char *pSource)
440{
441 NOISE_DETECTOR_RET_t tRet = ND_NORMAL;
442
443 unsigned short Offset, XNum, i, j;
444 signed int i32NoiseLevel = 0;
445 signed int noise_value = 0;
446 signed char bdata, bdata0;
447 unsigned char bfTouched = 0;
448 signed char bTestData = 0;
449 unsigned char *pbBaseline;
450 unsigned short wSENum = 2;
451
452
453#if ENABLE_T007B1_SETTING
454 if (g_stCtrl.bICVersion == T007_VERSION_B)
455 {
456 wSENum = 0;
457 return ND_DETECTOR_OFF;
458 }
459#endif
460
461 if (!g_stCtrl.bfNoiseDetector)
462 return ND_DETECTOR_OFF;
463
464#if ENABLE_NEW_NOISE_MODE
465 if (g_stCtrl.bfNoiseModeDetector)
466 pSource[0] = 0x10;
467 else
468 pSource[0] = 0x00;
469
470 if (g_stCtrl.bfNoiseModeDetector && (g_stCtrl.bfNoiseMode & 0x02))
471 pbBaseline = g_pbAnalogBaseline;
472 else
473#endif
474 pbBaseline = g_pbBaseline;
475
476 if (g_stCtrl.bBaselineReady) {
477 if (g_stCtrl.bChannelDetectorNum > 0) {
478 bfTouched = 0;
479 XNum = g_stCtrl.bChannelNumberX + wSENum + g_stCtrl.bADCNumber;
480 Offset = XNum * (g_stCtrl.bChannelNumberY + g_stCtrl.bChannelDetectorDummy);
481 for (i = 0; i < XNum; i++) {
482 if (g_stCtrl.bADCNumber) {
483 if ((i == g_stCtrl.bDummyChannel[0])
484 || (i == g_stCtrl.bDummyChannel[1])
485 || (i == g_stCtrl.bDummyChannel[2])
486 || (i == g_stCtrl.bDummyChannel[3])) {
487 continue;
488 }
489 } else {
490 if ((i == g_stCtrl.bDummyChannel[0]) || (i == g_stCtrl.bDummyChannel[1])) {
491 continue;
492 }
493 }
494
495 bTestData = 0;
496 for (j = 0; j < g_stCtrl.bChannelNumberY; j++) {
497 bTestData = pbBaseline[j * XNum + i] - pSource[j * XNum + i];
498 if (bTestData > g_stCtrl.bMTTouchThreshold || bTestData < -g_stCtrl.bMTTouchThreshold) {
499 bfTouched = 1;
500 break;
501 }
502 }
503 if (bfTouched == 1)
504 break;
505 }
506 for (i = 0; i < XNum; i++) {
507 bfSign[i] = 0;
508 for (j = 0; j < g_stCtrl.bChannelDetectorNum; j++) {
509 bDTImage[i][j] = pbBaseline[Offset + j * XNum + i] - pSource[Offset + j * XNum + i];
510 }
511 }
512 for (i = 0; i < XNum; i++) {
513 bdata = 0;
514 bdata0 = 0;
515 for (j = 0; j < g_stCtrl.bChannelDetectorNum; j++) {
516 if (bDTImage[i][j] > 0) {
517 bdata++;
518 } else if (bDTImage[i][j] < 0) {
519 bdata--;
520 } else {
521 bdata0++;
522 }
523 }
524 if (((bdata + bdata0) == g_stCtrl.bChannelDetectorNum) || ((bdata0 - bdata) == g_stCtrl.bChannelDetectorNum)) {
525 bfSign[i] = 1;
526 }
527 }
528
529 i32NoiseLevel = 0;
530 for (i = 0; i < XNum; i++) {
531 if (g_stCtrl.bADCNumber) {
532 if ((i == g_stCtrl.bDummyChannel[0])
533 || (i == g_stCtrl.bDummyChannel[1])
534 || (i == g_stCtrl.bDummyChannel[2])
535 || (i == g_stCtrl.bDummyChannel[3])) {
536 continue;
537 }
538 } else {
539 if ((i == g_stCtrl.bDummyChannel[0]) || (i == g_stCtrl.bDummyChannel[1])) {
540 continue;
541 }
542 }
543
544 for (j = 0; j < g_stCtrl.bChannelDetectorNum; j++) {
545 if (bDTImage[i][j] < 0)
546 noise_value = -bDTImage[i][j];
547 else
548 noise_value = bDTImage[i][j];
549
550 if (noise_value > 2 && ((bfSign[i] == 0 && g_stCtrl.bfNoiseModeDetector == 0) || g_stCtrl.bfNoiseModeDetector == 1)) {
551 i32NoiseLevel += noise_value;
552 }
553 }
554 }
555
556 if (g_noisechecktimes == 0) {
557 g_noiseLevel[0] = i32NoiseLevel;
558 } else if (g_noisechecktimes == 1) {
559 g_noiseLevel[1] = i32NoiseLevel;
560 } else if (g_noisechecktimes == 2) {
561 g_noiseLevel[2] = i32NoiseLevel;
562 } else {
563 g_noiseLevel[0] = g_noiseLevel[1];
564 g_noiseLevel[1] = g_noiseLevel[2];
565 g_noiseLevel[2] = i32NoiseLevel;
566 }
567 i32NoiseLevel = g_noiseLevel[0] + g_noiseLevel[1] + g_noiseLevel[2];
568 g_noisechecktimes++;
569 if (g_noisechecktimes > 50) {
570 g_noisechecktimes = 50;
571 }
572
573 if (g_stCtrl.bfNoiseModeDetector == 0) {
574 if (i32NoiseLevel > g_stCtrl.bNoiseDetectThd || g_stCtrl.bfNoisePreHold > 5) {
575 if ((g_noiseLevel[0] != 0) && (g_noiseLevel[1] != 0) && (g_noiseLevel[2] != 0)) {
576
577 rm31080_disable_touch();
578 msleep(10);
579 rm31080_ctrl_clear_int();
580#if ENABLE_NEW_NOISE_MODE
581 if (g_stCtrl.bfNoiseMode & 0x02)
582 {
583 rm31080_analog_filter_config(g_stCtrl.bNewNoiseRepeatTimes);
584 }
585 else
586#endif
587 {
588 rm_set_repeat_times(REPEAT_1);
589 }
590 g_stCtrl.bfNoiseModeDetector = 1;
591 g_stCtrl.bfNoisePreHold = 0;
592 //printk("Enter Noise Mode! \n");
593 tRet = ND_NOISE_DETECTED;
594
595 rm31080_enable_touch();
596 rm31080_ctrl_scan_start();
597 }
598 }
599 else {
600 if (!g_stCtrl.bfTouched && bfTouched && i32NoiseLevel > 0)
601 g_stCtrl.bfNoisePreHold++;
602 else if (g_stCtrl.bfNoisePreHold && bfTouched && i32NoiseLevel > 0
603 && (g_noiseLevel[0] != 0)
604 && (g_noiseLevel[1] != 0)
605 && (g_noiseLevel[2] != 0))
606 g_stCtrl.bfNoisePreHold++;
607 else
608 g_stCtrl.bfNoisePreHold = 0;
609 }
610 }
611 else {
612 if (g_stCtrl.bfNoiseModeDetector == 1 && !g_stCtrl.bfSuspendReset){
613 if (bfTouched == 0){
614 rm31080_disable_touch();
615 msleep(50);
616 rm31080_ctrl_clear_int();
617
618#if ENABLE_NEW_NOISE_MODE
619 if (g_stCtrl.bfNoiseMode & 0x02){
620 if (g_stCtrl.bfAnalogFilter)
621 rm_set_repeat_times(g_stCtrl.bRepeatTimes[1]);
622 else
623 rm31080_digital_filter_config();
624 }
625 else
626#endif
627 {
628 rm_set_repeat_times(g_stCtrl.bRepeatTimes[g_stCtrl.bfAnalogFilter]);
629 }
630 g_stCtrl.bfNoiseModeDetector = 0;
631 g_stCtrl.bfNoisePreHold = 0;
632 g_stCtrl.bfExitNoiseMode = 1;
633
634 //printk("Exit Noise Mode! \n");
635 tRet = ND_LEAVE_NOISE_MODE;
636
637 rm31080_enable_touch();
638 rm31080_ctrl_scan_start();
639 }
640
641 }
642 }
643#if 0
644 if (u16ShowCnt > 20) {
645 printk("L1,%d\n", g_noiseLevel[0]);
646 printk("L2,%d\n", g_noiseLevel[1]);
647 printk("L3,%d\n", g_noiseLevel[2]);
648 printk("NL,%d\n", i32NoiseLevel);
649 printk("Nm,%d\n", g_stCtrl.bfNoiseModeDetector);
650 u16ShowCnt = 0;
651 }
652 u16ShowCnt++;
653#endif
654 }
655 else
656 return ND_BASELINE_NOT_READY;
657
658 g_stCtrl.bfTouched = bfTouched;
659 }
660
661 return tRet;
662}
663
664//=============================================================================
665int rm_noise_main(signed char *pSource)
666{
667 int iRet = 1;
668
669 if (ND_NOISE_DETECTED == rm_noise_detect(pSource))
670 iRet = 0;
671
672#if ENABLE_T007B1_SETTING
673 if (g_stCtrl.bICVersion != T007_VERSION_B)
674#endif
675 {
676#if ENABLE_NEW_NOISE_MODE
677 if (!(g_stCtrl.bfNoiseMode & 0x02))
678#endif
679 {
680 iRet = rm31080_soft_average(pSource);
681 }
682 }
683
684 return iRet;
685}
686
687//=============================================================================
688// Description:
689//
690// Input:
691// N/A
692// Output:
693// N/A
694//=============================================================================
695void rm31080_ctrl_set_baseline(void *arg)
696{
697 u8 *pRawPtr;
698 u16 ii;
699 pRawPtr = (u8 *) arg;
700 for (ii = 0; ii < g_stCtrl.u16DataLength; ii++) {
701 g_pbBaseline[ii] = pRawPtr[ii + 1];
702 }
703 g_stCtrl.bBaselineReady = 1;
704}
705
706#if ENABLE_NEW_NOISE_MODE
707//=============================================================================
708// Description:
709//
710// Input:
711// N/A
712// Output:
713// N/A
714//=============================================================================
715void rm31080_ctrl_set_analog_baseline(void *arg)
716{
717 u8 *pRawPtr;
718 u16 ii;
719 pRawPtr = (u8 *) arg;
720 for (ii = 0; ii < g_stCtrl.u16DataLength; ii++) {
721 g_pbAnalogBaseline[ii] = pRawPtr[ii];
722 }
723 g_stCtrl.bBaselineReady = 1;
724}
725#endif
726//=============================================================================
727// Description:
728//
729// Input:
730// N/A
731// Output:
732// N/A
733//=============================================================================
734void rm31080_ctrl_init(void)
735{
736#if ENABLE_T007B1_SETTING
737 u8 var;
738#endif
739 memset(&g_stCtrl, 0, sizeof(struct rm31080a_ctrl_para));
740 //Marty added
741 g_stCtrl.bBaselineReady = 0; // Noise_Detector
742 g_noiseLevel[0] = 0; // Noise_Detector
743 g_noiseLevel[1] = 0; // Noise_Detector
744 g_noiseLevel[2] = 0; // Noise_Detector
745 g_noisechecktimes = 0; // Noise_Detector
746 g_stCtrl.bfNoiseModeDetector = 0;
747 g_stCtrl.bfNoisePreHold = 0;
748 g_stCtrl.bfTouched = 0;
749 g_stCtrl.bfExitNoiseMode = 0;
750
751 g_stCtrl.u16DataLength = RM31080_RAW_DATA_LENGTH;
752 g_bfFirstAverage = 0;
753
754#if ENABLE_T007B1_SETTING
755 if (rm31080_spi_byte_read(RM31080_REG_7E, &var))
756 g_stCtrl.bICVersion = var & 0xF0;
757 else
758 g_stCtrl.bICVersion = T007A6;
759#endif
760}
761
762//=============================================================================
763// Description:
764//
765// Input:
766// N/A
767// Output:
768// N/A
769//=============================================================================
770unsigned char rm31080_ctrl_get_noise_mode(u8 * p)
771{
772 u32 u32Ret;
773 u32Ret = copy_to_user(p, &g_stCtrl.bfNoiseModeDetector, 1);
774 if (u32Ret != 0)
775 return 0;
776 return 1;
777}
778
779
780#if ENABLE_T007B1_SETTING
781
782void rm31080b_sw_reset(void)
783{
784 unsigned char u8Value;
785
786 // sw reset
787 rm31080_spi_byte_read(RM31080B1_REG_BANK0_11H, &u8Value);
788 u8Value &= ~0x04;
789 rm31080_spi_byte_write(RM31080B1_REG_BANK0_11H, u8Value); // Send software reset.
790}
791
792//=============================================================================
793// Description: Set T007B analog filter repeat
794//
795// Input:
796// Analog average tap number
797// Output:
798// none
799//=============================================================================
800void rm31080b_analog_filter_config(unsigned char u8Amount)
801{
802 unsigned char u8Value;
803
804 rm31080_spi_byte_read(RM31080B1_REG_BANK0_0BH,&u8Value);
805 u8Value &= ~0x0F;
806 u8Value |= u8Amount;
807 rm31080_spi_byte_write(RM31080B1_REG_BANK0_0BH, u8Amount);
808
809 rm31080b_sw_reset();
810}
811
812
813//=============================================================================
814// Description: Set T007B digital filter repeat
815//
816// Input:
817// Digital average tap number
818// Output:
819// none
820//=============================================================================
821void rm31080b_digital_filter_config(unsigned char u8Amount)
822{
823 unsigned char u8Value;
824
825 rm31080_spi_byte_read(RM31080B1_REG_BANK0_0EH, &u8Value);
826 u8Value &= ~0x1F;
827 u8Value |= u8Amount;
828 rm31080_spi_byte_write(RM31080B1_REG_BANK0_0EH, u8Value);
829
830 rm31080b_sw_reset();
831}
832#endif // #if ENABLE_T007B1_SETTING
833
834//=============================================================================
835// Description:
836//
837// Input:
838// N/A
839// Output:
840// N/A
841//=============================================================================
842
843#if ENABLE_FILTER_SWITCH
844void rm31080_analog_filter_config(u8 bRepeatTimes)
845{
846#if ENABLE_T007B1_SETTING
847 if (g_stCtrl.bICVersion != T007_VERSION_B)
848#endif
849 {
850 //u8 bReg0_1Fh = 0x00;
851
852 //InitChargePump();
853 rm31080_spi_byte_write(0x7F, 0x01); // Switch to 0x01
854
855 rm31080_spi_byte_write(0x09, g_stCtrl.bReg1_09h[1]);
856 rm31080_spi_byte_write(0x43, g_stCtrl.bReg1_43h[1]);
857 rm31080_spi_byte_write(0x48, g_stCtrl.bReg1_48h[1]);
858 rm31080_spi_byte_write(0x49, g_stCtrl.bReg1_49h[1]);
859 rm31080_spi_byte_write(0x4A, g_stCtrl.bReg1_4Ah[1]);
860 rm31080_spi_byte_write(0x4B, g_stCtrl.bReg1_4Bh[1]);
861
862 rm31080_spi_byte_write(0x7F, 0x00); // Switch to BANK0
863
864 #if 0
865 rm31080_spi_byte_write(0x0E, ( 0x38 | 0x00)); //bSenseNumber = 8, REPEAT_1
866
867 rm31080_spi_byte_read(0x1F, &bReg0_1Fh);
868 bReg0_1Fh = bReg0_1Fh & 0xF8;
869 bReg0_1Fh = bReg0_1Fh | 0x00; //REPEAT_1
870 rm31080_spi_byte_write(0x1F, bReg0_1Fh);
871 #endif
872 rm_set_repeat_times(bRepeatTimes);
873
874 // -------- Set Driving / Sensing Control Mode --------
875 rm31080_spi_byte_write(RM31080_REG_10, 0x80); //SSC_ENB
876
877 // -------- Set PGA/DAC --------
878 rm31080_spi_byte_write(0x6B, 0xF1); //CSSEL
879
880 // -------- Scan Time Setting --------
881 rm31080_spi_byte_write(RM31080_REG_42, g_stCtrl.bReg0_42h[1]); //LACTIVE
882 rm31080_spi_byte_write(RM31080_REG_43, g_stCtrl.bReg0_43h[1]); //LACTIVE
883
884 rm31080_spi_byte_write(0x20, g_stCtrl.bReg0_20h[1]);
885 rm31080_spi_byte_write(0x21, g_stCtrl.bReg0_21h[1]);
886 rm31080_spi_byte_write(0x22, g_stCtrl.bReg0_22h[1]);
887 rm31080_spi_byte_write(0x23, g_stCtrl.bReg0_23h[1]);
888 rm31080_spi_byte_write(0x24, g_stCtrl.bReg0_24h[1]);
889 rm31080_spi_byte_write(0x25, g_stCtrl.bReg0_25h[1]);
890 rm31080_spi_byte_write(0x26, g_stCtrl.bReg0_26h[1]);
891 rm31080_spi_byte_write(0x27, g_stCtrl.bReg0_27h[1]);
892 rm31080_spi_byte_write(0x28, g_stCtrl.bReg0_28h[1]);
893 rm31080_spi_byte_write(0x29, g_stCtrl.bReg0_29h[1]);
894 rm31080_spi_byte_write(0x2A, g_stCtrl.bReg0_2Ah[1]);
895 rm31080_spi_byte_write(0x2B, g_stCtrl.bReg0_2Bh[1]);
896 rm31080_spi_byte_write(0x2C, g_stCtrl.bReg0_2Ch[1]);
897 rm31080_spi_byte_write(0x2D, g_stCtrl.bReg0_2Dh[1]);
898 rm31080_spi_byte_write(0x2E, g_stCtrl.bReg0_2Eh[1]);
899 rm31080_spi_byte_write(0x2F, g_stCtrl.bReg0_2Fh[1]);
900 rm31080_spi_byte_write(0x30, g_stCtrl.bReg0_30h[1]);
901 rm31080_spi_byte_write(0x31, g_stCtrl.bReg0_31h[1]);
902 rm31080_spi_byte_write(0x32, g_stCtrl.bReg0_32h[1]);
903 rm31080_spi_byte_write(0x33, g_stCtrl.bReg0_33h[1]);
904 }
905}
906
907void rm31080_digital_filter_config(void)
908{
909#if ENABLE_T007B1_SETTING
910 if (g_stCtrl.bICVersion != T007_VERSION_B)
911#endif
912 {
913 //u8 bReg0_1Fh = 0x00;
914
915 //InitChargePump();
916 rm31080_spi_byte_write(0x7F, 0x01); // Switch to BANK1
917
918 rm31080_spi_byte_write(0x09, g_stCtrl.bReg1_09h[0]);
919 rm31080_spi_byte_write(0x43, g_stCtrl.bReg1_43h[0]);
920 rm31080_spi_byte_write(0x48, g_stCtrl.bReg1_48h[0]);
921 rm31080_spi_byte_write(0x49, g_stCtrl.bReg1_49h[0]);
922 rm31080_spi_byte_write(0x4A, g_stCtrl.bReg1_4Ah[0]);
923 rm31080_spi_byte_write(0x4B, g_stCtrl.bReg1_4Bh[0]);
924
925 rm31080_spi_byte_write(0x7F, 0x00); // Switch to 0x00
926
927 #if 0
928 rm31080_spi_byte_write(0x0E, ( 0x38 | 0x04)); //bSenseNumber = 8, REPEAT_5
929
930 rm31080_spi_byte_read(0x1F, &bReg0_1Fh);
931 bReg0_1Fh = bReg0_1Fh & 0xF8;
932 bReg0_1Fh = bReg0_1Fh | 0x07;//REPEAT_5
933
934 rm31080_spi_byte_write(0x1F, bReg0_1Fh);
935 #endif
936 rm_set_repeat_times(g_stCtrl.bRepeatTimes[0]);
937
938// -------- Set Driving / Sensing Control Mode --------
939 if(!g_stCtrl.bfAnalogFilter)
940 {
941 rm31080_spi_byte_write(RM31080_REG_10, 0x10 |0x40); //ACC | DDSC
942 }
943
944// -------- Set PGA/DAC --------
945 rm31080_spi_byte_write(0x6B, 0x04); //EN_C0
946
947// -------- Scan Time Setting --------
948 rm31080_spi_byte_write(RM31080_REG_42, g_stCtrl.bReg0_42h[g_stCtrl.bfAnalogFilter]); //LACTIVE
949 rm31080_spi_byte_write(RM31080_REG_43, g_stCtrl.bReg0_43h[g_stCtrl.bfAnalogFilter]); //LACTIVE
950
951 rm31080_spi_byte_write(0x20, g_stCtrl.bReg0_20h[g_stCtrl.bfAnalogFilter]);
952 rm31080_spi_byte_write(0x21, g_stCtrl.bReg0_21h[g_stCtrl.bfAnalogFilter]);
953 rm31080_spi_byte_write(0x22, g_stCtrl.bReg0_22h[g_stCtrl.bfAnalogFilter]);
954 rm31080_spi_byte_write(0x23, g_stCtrl.bReg0_23h[g_stCtrl.bfAnalogFilter]);
955 rm31080_spi_byte_write(0x24, g_stCtrl.bReg0_24h[g_stCtrl.bfAnalogFilter]);
956 rm31080_spi_byte_write(0x25, g_stCtrl.bReg0_25h[g_stCtrl.bfAnalogFilter]);
957 rm31080_spi_byte_write(0x26, g_stCtrl.bReg0_26h[g_stCtrl.bfAnalogFilter]);
958 rm31080_spi_byte_write(0x27, g_stCtrl.bReg0_27h[g_stCtrl.bfAnalogFilter]);
959 rm31080_spi_byte_write(0x28, g_stCtrl.bReg0_28h[g_stCtrl.bfAnalogFilter]);
960 rm31080_spi_byte_write(0x29, g_stCtrl.bReg0_29h[g_stCtrl.bfAnalogFilter]);
961 rm31080_spi_byte_write(0x2A, g_stCtrl.bReg0_2Ah[g_stCtrl.bfAnalogFilter]);
962 rm31080_spi_byte_write(0x2B, g_stCtrl.bReg0_2Bh[g_stCtrl.bfAnalogFilter]);
963 rm31080_spi_byte_write(0x2C, g_stCtrl.bReg0_2Ch[g_stCtrl.bfAnalogFilter]);
964 rm31080_spi_byte_write(0x2D, g_stCtrl.bReg0_2Dh[g_stCtrl.bfAnalogFilter]);
965 rm31080_spi_byte_write(0x2E, g_stCtrl.bReg0_2Eh[g_stCtrl.bfAnalogFilter]);
966 rm31080_spi_byte_write(0x2F, g_stCtrl.bReg0_2Fh[g_stCtrl.bfAnalogFilter]);
967 rm31080_spi_byte_write(0x30, g_stCtrl.bReg0_30h[g_stCtrl.bfAnalogFilter]);
968 rm31080_spi_byte_write(0x31, g_stCtrl.bReg0_31h[g_stCtrl.bfAnalogFilter]);
969 rm31080_spi_byte_write(0x32, g_stCtrl.bReg0_32h[g_stCtrl.bfAnalogFilter]);
970 rm31080_spi_byte_write(0x33, g_stCtrl.bReg0_33h[g_stCtrl.bfAnalogFilter]);
971 }
972}
973
974void rm31080_filter_config(void)
975{
976#if ENABLE_FILTER_SWITCH
977#if ENABLE_T007B1_SETTING
978 if (g_stCtrl.bICVersion != T007_VERSION_B)
979#endif
980 {
981 if (g_stCtrl.bfAnalogFilter)
982 {
983#if ENABLE_NEW_NOISE_MODE
984 if ((g_stCtrl.bfNoiseMode & 0x02) && g_stCtrl.bfNoiseDetector)
985 {
986 if (g_stCtrl.bfNoiseModeDetector)
987 {
988 rm_set_repeat_times(g_stCtrl.bNewNoiseRepeatTimes);
989 }
990 else
991 {
992 rm_set_repeat_times(g_stCtrl.bRepeatTimes[1]);
993 }
994 }
995 else
996 rm_set_repeat_times(g_stCtrl.bRepeatTimes[1]);
997#else
998 rm31080_analog_filter_config(g_stCtrl.bRepeatTimes[1]);
999#endif
1000 //rm_printk("Analog Setting with %d Repeat Times \n", (g_stCtrl.bRepeatTimes[1] + 1));
1001 }
1002 else
1003 {
1004#if ENABLE_NEW_NOISE_MODE
1005 if ((g_stCtrl.bfNoiseMode & 0x02) && g_stCtrl.bfNoiseDetector)
1006 {
1007 if (g_stCtrl.bfNoiseModeDetector)
1008 {
1009 rm_set_repeat_times(g_stCtrl.bNewNoiseRepeatTimes);
1010 }
1011 else
1012 {
1013 rm31080_digital_filter_config();
1014 }
1015 }
1016 else
1017#endif
1018 rm31080_digital_filter_config();
1019 //rm_printk("Digital Setting with %d Repeat Times \n", (g_stCtrl.bRepeatTimes[0]));
1020 }
1021 //rm_printk("Disable Analog Filter\n");
1022#endif
1023}
1024
1025#endif
1026//=============================================================================
1027// Description:
1028//
1029// Input:
1030// N/A
1031// Output:
1032// N/A
1033//=============================================================================
1034void rm31080_ctrl_get_parameter(void *arg)
1035{
1036#define PARA_BASIC_LEN 4
1037#define PARA_HARDWARE_LEN 28
1038#define PARA_NOISE_LEN 32
1039#define PARA_ALGORITHM_LEN 128
1040
1041 //Marty added
1042 u8 Temp;
1043 s8 bBlockInterval;
1044 u16 ii;
1045 u8 *pPara;
1046
1047 pPara = (u8 *) arg;
1048 Temp = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + PARA_NOISE_LEN + PARA_ALGORITHM_LEN + 3];
1049 rm31080_set_autoscan(Temp);
1050
1051 g_stCtrl.bADCNumber = pPara[PARA_BASIC_LEN + 6];
1052 g_stCtrl.bChannelNumberX = pPara[PARA_BASIC_LEN];
1053 g_stCtrl.bChannelNumberY = pPara[PARA_BASIC_LEN + 1];
1054 g_stCtrl.bfNoiseDetector = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 13];
1055 g_stCtrl.bChannelDetectorNum = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 19]; // Noise_Detector
1056 g_stCtrl.bChannelDetectorDummy = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 20]; // Noise_Detector
1057 g_stCtrl.u16DataLength = (g_stCtrl.bChannelNumberX + 2 + g_stCtrl.bADCNumber) *
1058 (g_stCtrl.bChannelNumberY + g_stCtrl.bfNoiseDetector * (g_stCtrl.bChannelDetectorNum + g_stCtrl.bChannelDetectorDummy));
1059 g_stCtrl.bfNoiseMode = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 14];
1060 g_stCtrl.bNoiseRepeatTimes = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 15];
1061 //Marty added
1062 g_stCtrl.bNoiseThresholdMax = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 21]; // Noise_Detector
1063 g_stCtrl.bNoiseThresholdMin = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 22]; // Noise_Detector
1064 g_stCtrl.bNoiseThresholdLowMax = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 23]; // Noise_Detector
1065 g_stCtrl.bNoiseThresholdLowMin = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 24]; // Noise_Detector
1066 g_stCtrl.bNoiseDetectThd = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 16]; // Noise_Detector
1067 g_stCtrl.bNoisePipelineBase = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 17]; // Noise_Detector
1068 g_stCtrl.bNewNoiseRepeatTimes = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 18]; // Noise_Detector
1069 g_stCtrl.bfMediumFilter = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 25]; // Noise_Detector
1070 g_stCtrl.bMFBlockNumber = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 26]; // Noise_Detector
1071 g_stCtrl.bRepeatTimes[0] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 4]; // Noise_Detector
1072 g_stCtrl.bRepeatTimes[1] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 5]; // Noise_Detector
1073 g_stCtrl.bIdleRepeatTimes[0] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 6];
1074 g_stCtrl.bSenseNumber = pPara[PARA_BASIC_LEN + 11]; // Noise_Detector
1075 g_stCtrl.bfADFC = pPara[PARA_BASIC_LEN + 4]; // Noise_Detector
1076 g_stCtrl.bfTHMode = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 10]; // Noise_Detector
1077 g_stCtrl.bfAnalogFilter = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 8]; // Noise_Detector
1078 g_stCtrl.bYChannel[0] = pPara[280]; // Y chan start pin
1079 g_stCtrl.bYChannel[1] = pPara[281]; // Y chan end pin
1080 g_stCtrl.bXChannel[0] = pPara[282]; // X chan ADC1 start pin
1081 g_stCtrl.bXChannel[1] = pPara[283]; // X chan ADC1 end pin
1082 g_stCtrl.bXChannel[2] = pPara[284]; // X chan ADC2 start pin
1083 g_stCtrl.bXChannel[3] = pPara[285]; // X chan ADC2 end pin
1084 g_stCtrl.bfSuspendReset = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 27];
1085 g_stCtrl.bPressureResolution = pPara[105];
1086 g_stCtrl.bMTTouchThreshold = pPara[192];
1087 g_stCtrl.bTime2Idle = pPara[194];
1088 g_stCtrl.bfPowerMode= pPara[195];
1089 //
1090 // Store dummy channel to skip it, data sequence:
1091 // Dummy[0](single end) | raw_data | dummy[1](single end) dummy[2](single end) | raw_data | dummy[3](single end)
1092 g_stCtrl.bDummyChannel[0] = 0;
1093 if (g_stCtrl.bfMediumFilter) {
1094 bBlockInterval = (g_stCtrl.bNoiseThresholdMax - g_stCtrl.bNoiseThresholdMin) / g_stCtrl.bMFBlockNumber;
1095 //printk("Block Interval = %d\n", bBlockInterval);
1096 for (ii = 0; ii < g_stCtrl.bMFBlockNumber; ii++) {
1097 g_bMFBlockMin[ii] = g_stCtrl.bNoiseThresholdMin + bBlockInterval * ii;
1098 g_bMFBlockMax[ii] = g_bMFBlockMin[ii] + bBlockInterval;
1099 //printk("Block %d, Max = %d, Min = %d\n", ii, g_bMFBlockMax[ii], g_bMFBlockMin[ii]);
1100 }
1101 }
1102 if (g_stCtrl.bADCNumber) {
1103 if (g_stCtrl.bYChannel[0] > g_stCtrl.bXChannel[0]) {
1104 if (g_stCtrl.bXChannel[0] < g_stCtrl.bXChannel[2]) {
1105 if (g_stCtrl.bXChannel[0] < g_stCtrl.bXChannel[1])
1106 Temp = g_stCtrl.bXChannel[1] - g_stCtrl.bXChannel[0];
1107 else
1108 Temp = g_stCtrl.bXChannel[0] - g_stCtrl.bXChannel[1];
1109 g_stCtrl.bDummyChannel[1] = Temp + 1;
1110 g_stCtrl.bDummyChannel[2] = Temp + 2;
1111 } else {
1112 if (g_stCtrl.bXChannel[2] < g_stCtrl.bXChannel[3])
1113 Temp = g_stCtrl.bXChannel[3] - g_stCtrl.bXChannel[2];
1114 else
1115 Temp = g_stCtrl.bXChannel[2] - g_stCtrl.bXChannel[3];
1116 g_stCtrl.bDummyChannel[1] = Temp + 1;
1117 g_stCtrl.bDummyChannel[2] = Temp + 2;
1118 }
1119 //#endif
1120 } else {
1121 if (g_stCtrl.bXChannel[0] > g_stCtrl.bXChannel[2]) {
1122 if (g_stCtrl.bXChannel[0] < g_stCtrl.bXChannel[1])
1123 Temp = g_stCtrl.bXChannel[1] - g_stCtrl.bXChannel[0];
1124 else
1125 Temp = g_stCtrl.bXChannel[0] - g_stCtrl.bXChannel[1];
1126 g_stCtrl.bDummyChannel[1] = Temp + 1;
1127 g_stCtrl.bDummyChannel[2] = Temp + 2;
1128 } else {
1129 if (g_stCtrl.bXChannel[2] < g_stCtrl.bXChannel[3])
1130 Temp = g_stCtrl.bXChannel[3] - g_stCtrl.bXChannel[2];
1131 else
1132 Temp = g_stCtrl.bXChannel[2] - g_stCtrl.bXChannel[3];
1133 g_stCtrl.bDummyChannel[1] = Temp + 1;
1134 g_stCtrl.bDummyChannel[2] = Temp + 2;
1135 }
1136
1137 }
1138 g_stCtrl.bDummyChannel[3] = g_stCtrl.bChannelNumberX + 2;
1139 } else {
1140 g_stCtrl.bDummyChannel[1] = g_stCtrl.bChannelNumberX + 1;
1141 }
1142#if ENABLE_RESOLUTION_SWITCH
1143 g_stCtrl.u16ResolutionX = ((u16) pPara[PARA_BASIC_LEN + 13]) << 8 | ((u16)pPara[PARA_BASIC_LEN + 12]);
1144 g_stCtrl.u16ResolutionY = ((u16) pPara[PARA_BASIC_LEN + 15]) << 8 | ((u16)pPara[PARA_BASIC_LEN + 14]);
1145// printk("g_stCtrl.u16ResolutionX=%d", g_stCtrl.u16ResolutionX);
1146// printk("g_stCtrl.u16ResolutionY=%d", g_stCtrl.u16ResolutionY);
1147 if ((g_stCtrl.u16ResolutionX == 0) || (g_stCtrl.u16ResolutionY == 0)) {
1148 g_stCtrl.u16ResolutionX = RM_INPUT_RESOLUTION_X;
1149 g_stCtrl.u16ResolutionY = RM_INPUT_RESOLUTION_Y;
1150 }
1151#endif
1152
1153#if ENABLE_FILTER_SWITCH
1154#if ENABLE_T007B1_SETTING
1155 if (g_stCtrl.bICVersion != T007_VERSION_B)
1156#endif
1157 {
1158 g_stCtrl.bReg1_09h[0] = pPara[327]; // Addr. 0327
1159 g_stCtrl.bReg1_09h[1] = pPara[328]; // Addr. 0328
1160 g_stCtrl.bReg1_43h[0] = pPara[337]; // Addr. 0337
1161 g_stCtrl.bReg1_43h[1] = pPara[338]; // Addr. 0338
1162 g_stCtrl.bReg1_48h[0] = pPara[339]; // Addr. 0339
1163 g_stCtrl.bReg1_48h[1] = pPara[340]; // Addr. 0340
1164 g_stCtrl.bReg1_49h[0] = pPara[341]; // Addr. 0341
1165 g_stCtrl.bReg1_49h[1] = pPara[342]; // Addr. 0342
1166 g_stCtrl.bReg1_4Ah[0] = pPara[343]; // Addr. 0343
1167 g_stCtrl.bReg1_4Ah[1] = pPara[344]; // Addr. 0344
1168 g_stCtrl.bReg1_4Bh[0] = pPara[345]; // Addr. 0345
1169 g_stCtrl.bReg1_4Bh[1] = pPara[346]; // Addr. 0346
1170
1171 g_stCtrl.bReg0_40h[0] = pPara[258];
1172 g_stCtrl.bReg0_40h[1] = pPara[259];
1173 g_stCtrl.bReg0_41h[0] = pPara[260];
1174 g_stCtrl.bReg0_41h[1] = pPara[261];
1175 g_stCtrl.bReg0_42h[0] = pPara[262]; // Addr. 0262
1176 g_stCtrl.bReg0_42h[1] = pPara[263]; // Addr. 0263
1177 g_stCtrl.bReg0_43h[0] = pPara[264]; // Addr. 0264
1178 g_stCtrl.bReg0_43h[1] = pPara[265]; // Addr. 0265
1179
1180// time chart
1181 g_stCtrl.bReg0_20h[0] = pPara[213]; // Addr. 0213
1182 g_stCtrl.bReg0_20h[1] = pPara[214]; // Addr. 0214
1183 g_stCtrl.bReg0_21h[0] = pPara[215]; // Addr. 0215
1184 g_stCtrl.bReg0_21h[1] = pPara[216]; // Addr. 0216
1185 g_stCtrl.bReg0_22h[0] = pPara[217]; // Addr. 0217
1186 g_stCtrl.bReg0_22h[1] = pPara[218]; // Addr. 0218
1187 g_stCtrl.bReg0_23h[0] = pPara[219]; // Addr. 0219
1188 g_stCtrl.bReg0_23h[1] = pPara[220]; // Addr. 0220
1189 g_stCtrl.bReg0_24h[0] = pPara[221]; // Addr. 0221
1190 g_stCtrl.bReg0_24h[1] = pPara[222]; // Addr. 0222
1191 g_stCtrl.bReg0_25h[0] = pPara[223]; // Addr. 0223
1192 g_stCtrl.bReg0_25h[1] = pPara[224]; // Addr. 0224
1193 g_stCtrl.bReg0_26h[0] = pPara[225]; // Addr. 0225
1194 g_stCtrl.bReg0_26h[1] = pPara[226]; // Addr. 0226
1195 g_stCtrl.bReg0_27h[0] = pPara[227]; // Addr. 0227
1196 g_stCtrl.bReg0_27h[1] = pPara[228]; // Addr. 0228
1197 g_stCtrl.bReg0_28h[0] = pPara[229]; // Addr. 0229
1198 g_stCtrl.bReg0_28h[1] = pPara[230]; // Addr. 0230
1199 g_stCtrl.bReg0_29h[0] = pPara[231]; // Addr. 0231
1200 g_stCtrl.bReg0_29h[1] = pPara[232]; // Addr. 0232
1201 g_stCtrl.bReg0_2Ah[0] = pPara[233]; // Addr. 0233
1202 g_stCtrl.bReg0_2Ah[1] = pPara[234]; // Addr. 0234
1203 g_stCtrl.bReg0_2Bh[0] = pPara[235]; // Addr. 0235
1204 g_stCtrl.bReg0_2Bh[1] = pPara[236]; // Addr. 0236
1205 g_stCtrl.bReg0_2Ch[0] = pPara[237]; // Addr. 0237
1206 g_stCtrl.bReg0_2Ch[1] = pPara[238]; // Addr. 0238
1207 g_stCtrl.bReg0_2Dh[0] = pPara[239]; // Addr. 0239
1208 g_stCtrl.bReg0_2Dh[1] = pPara[240]; // Addr. 0240
1209 g_stCtrl.bReg0_2Eh[0] = pPara[241]; // Addr. 0241
1210 g_stCtrl.bReg0_2Eh[1] = pPara[242]; // Addr. 0242
1211 g_stCtrl.bReg0_2Fh[0] = pPara[243]; // Addr. 0243
1212 g_stCtrl.bReg0_2Fh[1] = pPara[244]; // Addr. 0244
1213 g_stCtrl.bReg0_30h[0] = pPara[245]; // Addr. 0245
1214 g_stCtrl.bReg0_30h[1] = pPara[246]; // Addr. 0246
1215 g_stCtrl.bReg0_31h[0] = pPara[247]; // Addr. 0247
1216 g_stCtrl.bReg0_31h[1] = pPara[248]; // Addr. 0248
1217 g_stCtrl.bReg0_32h[0] = pPara[249]; // Addr. 0249
1218 g_stCtrl.bReg0_32h[1] = pPara[250]; // Addr. 0250
1219 g_stCtrl.bReg0_33h[0] = pPara[251]; // Addr. 0251
1220 g_stCtrl.bReg0_33h[1] = pPara[252]; // Addr. 0252
1221 }
1222#endif
1223}
1224
1225//=============================================================================
1226MODULE_AUTHOR("xxxxxxxxxx <xxxxxxxx@rad-ic.com>");
1227MODULE_DESCRIPTION("Raydium touchscreen control functions");
1228MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-17 22:24:28 -0400