drivers/input/touchscreen/mediatek/synaptics_2202/RefCode_F54_RxToRxReport.c

   1 /*
   2    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   3    Copyright (c) 2011 Synaptics, Inc.
   4
   5    Permission is hereby granted, free of charge, to any person obtaining a copy of
   6    this software and associated documentation files (the "Software"), to deal in
   7    the Software without restriction, including without limitation the rights to use,
   8    copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   9    Software, and to permit persons to whom the Software is furnished to do so,
  10    subject to the following conditions:
  11
  12    The above copyright notice and this permission notice shall be included in all
  13    copies or substantial portions of the Software.
  14
  15    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21    SOFTWARE.
  22
  23    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  24 */
  25
  26 #include "RefCode.h"
  27 #include "RefCode_PDTScan.h"
  28
  29 #ifdef _F54_TEST_
  30
  31 #ifdef F54_Porting
  32 static unsigned char ImageBuffer[CFG_F54_TXCOUNT*CFG_F54_RXCOUNT*2];
  33 static short ImageArray[CFG_F54_RXCOUNT][CFG_F54_RXCOUNT];
  34 static char buf[3000] = {0};
  35 static int ret = 0;
  36 #endif
  37
  38 unsigned char F54_RxToRxReport(void)
  39 {
  40 #ifdef F54_Porting
  41 #else
  42    unsigned char ImageBuffer[CFG_F54_TXCOUNT*CFG_F54_RXCOUNT*2];
  43    short ImageArray[CFG_F54_RXCOUNT][CFG_F54_RXCOUNT];
  44 #endif
  45    //char Result[CFG_F54_RXCOUNT][CFG_F54_RXCOUNT];
  46    int Result=0;
  47
  48    short DiagonalLowerLimit = 900;
  49    short DiagonalUpperLimit = 1100;
  50    short OthersLowerLimit = -100;
  51    short OthersUpperLimit = 100;
  52
  53    int i, j, k;
  54    int length;
  55
  56    unsigned char command;
  57
  58 #ifdef F54_Porting
  59         memset(buf, 0, sizeof(buf));
  60         ret = sprintf(buf, "\nBin #: 7          Name: Receiver To Receiver Short Test\n");
  61         ret += sprintf(buf+ret, "\n\t");
  62 #else
  63         printk("\nBin #: 7              Name: Receiver To Receiver Short Test\n");
  64         printk("\n\t");
  65 #endif
  66         for (j = 0; j < numberOfRx; j++)
  67 #ifdef F54_Porting
  68         ret += sprintf(buf+ret, "R%d\t", j);
  69 #else
  70         printk("R%d\t", j);
  71 #endif
  72
  73 #ifdef F54_Porting
  74         ret += sprintf(buf+ret, "\n");
  75 #else
  76         printk("\n");
  77 #endif
  78
  79    length =  numberOfRx * numberOfTx*2;
  80
  81    // Set report mode to run Rx-to-Rx 1st data
  82    command = 0x07;
  83    writeRMI(F54_Data_Base, &command, 1);
  84
  85    // Disable CBC
  86    command = 0x00;
  87    writeRMI(F54_CBCSettings, &command, 1);
  88
  89    //NoCDM4
  90    command = 0x01;
  91    writeRMI(NoiseMitigation, &command, 1);
  92
  93    // Force update
  94    command = 0x04;
  95    writeRMI(F54_Command_Base, &command, 1);
  96
  97    do {
  98                 delayMS(1); //wait 1ms
  99         readRMI(F54_Command_Base, &command, 1);
 100    } while (command != 0x00);
 101
 102    command = 0x02;
 103    writeRMI(F54_Command_Base, &command, 1);
 104
 105    do {
 106                 delayMS(1); //wait 1ms
 107         readRMI(F54_Command_Base, &command, 1);
 108    } while (command != 0x00);
 109
 110    //  command = 0x00;
 111    //   writeRMI(0x0113, &command, 1);
 112
 113    command = 0x00;
 114    writeRMI(F54_Data_LowIndex, &command, 1);
 115    writeRMI(F54_Data_HighIndex, &command, 1);
 116
 117    // Set the GetReport bit to run Tx-to-Tx
 118    command = 0x01;
 119    writeRMI(F54_Command_Base, &command, 1);
 120
 121    // Wait until the command is completed
 122    do {
 123                 delayMS(1); //wait 1ms
 124         readRMI(F54_Command_Base, &command, 1);
 125    } while (command != 0x00);
 126
 127    //readRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 128    longReadRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 129
 130    k = 0;
 131    for (i = 0; i < numberOfTx; i++)
 132    {
 133        for (j = 0; j < numberOfRx; j++)
 134            {
 135                         ImageArray[i][j] = (ImageBuffer[k] | (ImageBuffer[k+1] << 8));
 136                         k = k + 2;
 137            }
 138    }
 139
 140    // Set report mode to run Rx-to-Rx 2nd data
 141    length = numberOfRx* (numberOfRx-numberOfTx) * 2;
 142    command = 0x11;
 143    writeRMI(F54_Data_Base, &command, 1);
 144
 145    command = 0x00;
 146    writeRMI(F54_Data_LowIndex, &command, 1);
 147    writeRMI(F54_Data_HighIndex, &command, 1);
 148
 149    // Set the GetReport bit to run Tx-to-Tx
 150    command = 0x01;
 151    writeRMI(F54_Command_Base, &command, 1);
 152
 153    // Wait until the command is completed
 154    do {
 155                 delayMS(1); //wait 1ms
 156                 readRMI(F54_Command_Base, &command, 1);
 157    } while (command != 0x00);
 158
 159    //readRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 160    longReadRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 161
 162    k = 0;
 163    for (i = 0; i < (numberOfRx-numberOfTx); i++)
 164    {
 165        for (j = 0; j < numberOfRx; j++)
 166            {
 167                         ImageArray[numberOfTx+i][j] = ImageBuffer[k] | (ImageBuffer[k+1] << 8);
 168                         k = k + 2;
 169            }
 170    }
 171
 172    /*
 173    // Check against test limits
 174    printk("\nRxToRx Short Test Result :\n");
 175         for (i = 0; i < numberOfRx; i++)
 176         {
 177                 for (j = 0; j < numberOfRx; j++)
 178                 {
 179                         if (i == j)
 180                         {
 181                                 if((ImageArray[i][j] <= DiagonalUpperLimit) && (ImageArray[i][j] >= DiagonalUpperLimit))
 182                                         Result[i][j] = 'P'; //Pass
 183                                 else
 184                                         Result[i][j] = 'F'; //Fail
 185                                 //printk("%3d", ImageArray[i][j]);
 186                         }
 187                         else
 188                         {
 189                                 if(ImageArray[i][j] <= OthersUpperLimit)
 190                                         Result[i][j] = 'P'; //Fail
 191                                 else
 192                                         Result[i][j] = 'F'; //Fail
 193                         }
 194                         printk("%4d", ImageArray[i][j]);
 195                 }
 196                 printk("\n");
 197         }
 198         printk("\n");
 199         */
 200
 201         for (i = 0; i < numberOfRx; i++)
 202         {
 203 #ifdef F54_Porting
 204                 ret += sprintf(buf+ret, "R%d\t", i);
 205 #else
 206                 printk("R%d\t", i);
 207 #endif
 208                 for (j = 0; j < numberOfRx; j++)
 209                 {
 210                         if (i == j)
 211                         {
 212                                 if((ImageArray[i][j] <= DiagonalUpperLimit) && (ImageArray[i][j] >= DiagonalLowerLimit))
 213                                 {
 214                                         Result++; //Pass
 215 #ifdef F54_Porting
 216                                         ret += sprintf(buf+ret, "%d\t", ImageArray[i][j]);
 217 #else
 218                                         printk("%d\t", ImageArray[i][j]);
 219 #endif
 220                                 }
 221                                 else
 222                                 {
 223 #ifdef F54_Porting
 224                                         ret += sprintf(buf+ret, "%d(*)\t", ImageArray[i][j]);
 225 #else
 226                                         printk("%d(*)\t", ImageArray[i][j]);
 227 #endif
 228                                 }
 229                         }
 230                         else
 231                         {
 232                                 if((ImageArray[i][j] <= OthersUpperLimit) && (ImageArray[i][j] >= OthersLowerLimit))
 233                                 {
 234                                         Result++; //Pass
 235 #ifdef F54_Porting
 236                                         ret += sprintf(buf+ret, "%d\t", ImageArray[i][j]);
 237 #else
 238                                         printk("%d\t", ImageArray[i][j]);
 239 #endif
 240                                 }
 241                                 else
 242                                 {
 243 #ifdef F54_Porting
 244                                         ret += sprintf(buf+ret, "%d(*)\t", ImageArray[i][j]);
 245 #else
 246                                         printk("%d(*)\t", ImageArray[i][j]);
 247 #endif
 248                                 }
 249                         }
 250                 }
 251 #ifdef F54_Porting
 252                 ret += sprintf(buf+ret, "\n");
 253 #else
 254                 printk("\n");
 255 #endif
 256         }
 257
 258    // Set the Force Cal
 259    command = 0x02;
 260    writeRMI(F54_Command_Base, &command, 1);
 261
 262    do {
 263                 delayMS(1); //wait 1ms
 264         readRMI(F54_Command_Base, &command, 1);
 265    } while (command != 0x00);
 266
 267    //enable all the interrupts
 268 //   SetPage(0x00);
 269    //Reset
 270    command= 0x01;
 271    writeRMI(F01_Cmd_Base, &command, 1);
 272    delayMS(200);
 273    readRMI(F01_Data_Base+1, &command, 1); //Read Interrupt status register to Interrupt line goes to high
 274
 275    //printk("Result = %d, Rx*Rx= %d\n", Result, numberOfRx * numberOfRx);
 276    if(Result == numberOfRx * numberOfRx)
 277         {
 278 #ifdef F54_Porting
 279                 ret += sprintf(buf+ret, "Test Result: Pass\n");
 280                 write_log(buf);
 281 #else
 282                 printk("Test Result: Pass\n");
 283 #endif
 284                 return 1; //Pass
 285         }
 286    else
 287         {
 288 #ifdef F54_Porting
 289                 ret += sprintf(buf+ret, "Test Result: Fail\n");
 290                 write_log(buf);
 291 #else
 292                 printk("Test Result: Fail\n");
 293 #endif
 294                 return 0; //Fail
 295         }
 296 }
 297
 298 int F54_GetRxToRxReport(char *buf)
 299 {
 300         int Result=0;
 301         int ret = 0;
 302
 303         short DiagonalLowerLimit = 900;
 304         short DiagonalUpperLimit = 1100;
 305         short OthersLowerLimit = -100;
 306         short OthersUpperLimit = 100;
 307
 308         int i, j, k;
 309         int length;
 310
 311         unsigned char command;
 312         int waitcount;
 313
 314         ret += sprintf(buf+ret, "Info: Rx=%d\n", numberOfRx);
 315
 316         length =  numberOfRx * numberOfTx*2;
 317
 318         // Set report mode to run Rx-to-Rx 1st data
 319         command = 0x07;
 320         writeRMI(F54_Data_Base, &command, 1);
 321
 322         // Disable CBC
 323         command = 0x00;
 324         writeRMI(F54_CBCSettings, &command, 1);
 325
 326         //NoCDM4
 327         command = 0x01;
 328         writeRMI(NoiseMitigation, &command, 1);
 329
 330         // Force update
 331         command = 0x04;
 332         writeRMI(F54_Command_Base, &command, 1);
 333
 334         waitcount = 0;
 335         do {
 336                 if(++waitcount > 500)
 337                 {
 338                         pr_info("%s[%d], command = %d\n", __func__, __LINE__, command);
 339                         return ret;
 340                 }
 341                 delayMS(1); //wait 1ms
 342                 readRMI(F54_Command_Base, &command, 1);
 343         } while (command != 0x00);
 344
 345         command = 0x02;
 346         writeRMI(F54_Command_Base, &command, 1);
 347
 348         waitcount = 0;
 349         do {
 350                 if(++waitcount > 1000)
 351                 {
 352                         pr_info("%s[%d], command = %d\n", __func__, __LINE__, command);
 353                         return ret;
 354                 }
 355                 delayMS(1); //wait 1ms
 356                 readRMI(F54_Command_Base, &command, 1);
 357         } while (command != 0x00);
 358
 359         //  command = 0x00;
 360         //      writeRMI(0x0113, &command, 1);
 361
 362         command = 0x00;
 363         writeRMI(F54_Data_LowIndex, &command, 1);
 364         writeRMI(F54_Data_HighIndex, &command, 1);
 365
 366         // Set the GetReport bit to run Tx-to-Tx
 367         command = 0x01;
 368         writeRMI(F54_Command_Base, &command, 1);
 369
 370         // Wait until the command is completed
 371         waitcount = 0;
 372         do {
 373                 if(++waitcount > 500)
 374                 {
 375                         pr_info("%s[%d], command = %d\n", __func__, __LINE__, command);
 376                         return ret;
 377                 }
 378                 delayMS(1); //wait 1ms
 379                 readRMI(F54_Command_Base, &command, 1);
 380         } while (command != 0x00);
 381
 382         //readRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 383         longReadRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 384
 385         k = 0;
 386         for (i = 0; i < numberOfTx; i++)
 387         {
 388                 for (j = 0; j < numberOfRx; j++)
 389                 {
 390                         ImageArray[i][j] = (ImageBuffer[k] | (ImageBuffer[k+1] << 8));
 391                         k = k + 2;
 392                 }
 393         }
 394
 395         // Set report mode to run Rx-to-Rx 2nd data
 396         length = numberOfRx* (numberOfRx-numberOfTx) * 2;
 397         command = 0x11;
 398         writeRMI(F54_Data_Base, &command, 1);
 399
 400         command = 0x00;
 401         writeRMI(F54_Data_LowIndex, &command, 1);
 402         writeRMI(F54_Data_HighIndex, &command, 1);
 403
 404         // Set the GetReport bit to run Tx-to-Tx
 405         command = 0x01;
 406         writeRMI(F54_Command_Base, &command, 1);
 407
 408         // Wait until the command is completed
 409         waitcount = 0;
 410         do {
 411                 if(++waitcount > 500)
 412                 {
 413                         pr_info("%s[%d], command = %d\n", __func__, __LINE__, command);
 414                         return ret;
 415                 }
 416                 delayMS(1); //wait 1ms
 417                 readRMI(F54_Command_Base, &command, 1);
 418         } while (command != 0x00);
 419
 420         //readRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 421         longReadRMI(F54_Data_Buffer, &ImageBuffer[0], length);
 422
 423         k = 0;
 424         for (i = 0; i < (numberOfRx-numberOfTx); i++)
 425         {
 426                 for (j = 0; j < numberOfRx; j++)
 427                 {
 428                         ImageArray[numberOfTx+i][j] = ImageBuffer[k] | (ImageBuffer[k+1] << 8);
 429                         k = k + 2;
 430                 }
 431         }
 432
 433         /*
 434         // Check against test limits
 435         printk("\nRxToRx Short Test Result :\n");
 436         for (i = 0; i < numberOfRx; i++)
 437         {
 438         for (j = 0; j < numberOfRx; j++)
 439         {
 440         if (i == j)
 441         {
 442         if((ImageArray[i][j] <= DiagonalUpperLimit) && (ImageArray[i][j] >= DiagonalUpperLimit))
 443         Result[i][j] = 'P'; //Pass
 444         else
 445         Result[i][j] = 'F'; //Fail
 446         //printk("%3d", ImageArray[i][j]);
 447         }
 448         else
 449         {
 450         if(ImageArray[i][j] <= OthersUpperLimit)
 451         Result[i][j] = 'P'; //Fail
 452         else
 453         Result[i][j] = 'F'; //Fail
 454         }
 455         printk("%4d", ImageArray[i][j]);
 456         }
 457         printk("\n");
 458         }
 459         printk("\n");
 460          */
 461
 462         for (i = 0; i < numberOfRx; i++)
 463         {
 464                 for (j = 0; j < numberOfRx; j++)
 465                 {
 466                         if (i == j)
 467                         {
 468                                 if((ImageArray[i][j] <= DiagonalUpperLimit) && (ImageArray[i][j] >= DiagonalLowerLimit))
 469                                 {
 470                                         Result++; //Pass
 471                                         ret += sprintf(buf+ret, "%d", ImageArray[i][j]);
 472                                 }
 473                                 else
 474                                 {
 475                                         ret += sprintf(buf+ret, "%d(*)", ImageArray[i][j]);
 476                                 }
 477                         }
 478                         else
 479                         {
 480                                 if((ImageArray[i][j] <= OthersUpperLimit) && (ImageArray[i][j] >= OthersLowerLimit))
 481                                 {
 482                                         Result++; //Pass
 483                                         ret += sprintf(buf+ret, "%d", ImageArray[i][j]);
 484                                 }
 485                                 else
 486                                 {
 487                                         ret += sprintf(buf+ret, "%d(*)", ImageArray[i][j]);
 488                                 }
 489                         }
 490
 491                         if(j < (numberOfRx-1))
 492                                 ret += sprintf(buf+ret, " ");
 493                 }
 494                 ret += sprintf(buf+ret, "\n");
 495         }
 496
 497         // Set the Force Cal
 498         command = 0x02;
 499         writeRMI(F54_Command_Base, &command, 1);
 500
 501         waitcount = 0;
 502         do {
 503                 if(++waitcount > 500)
 504                 {
 505                         pr_info("%s[%d], command = %d\n", __func__, __LINE__, command);
 506                         break;
 507                 }
 508                 delayMS(1); //wait 1ms
 509                 readRMI(F54_Command_Base, &command, 1);
 510         } while (command != 0x00);
 511
 512
 513         //printk("Result = %d, Rx*Rx= %d\n", Result, numberOfRx * numberOfRx);
 514         if(Result == numberOfRx * numberOfRx)
 515         {
 516                 ret += sprintf(buf+ret, "RESULT: Pass\n");
 517         }
 518         else
 519         {
 520                 ret += sprintf(buf+ret, "RESULT: Fail\n");
 521         }
 522
 523         //enable all the interrupts
 524         //   SetPage(0x00);
 525         //Reset
 526         command= 0x01;
 527         writeRMI(F01_Cmd_Base, &command, 1);
 528         delayMS(200);
 529         readRMI(F01_Data_Base+1, &command, 1); //Read Interrupt status register to Interrupt line goes to high
 530         return ret;
 531 }
 532 #endif
 533