drivers/input/touchscreen/mcs8000_download.c

   1 //--------------------------------------------------------\r
   2 //\r
   3 //\r
   4 //      Melfas MCS8000 Series Download base v1.0 2010.04.05\r
   5 //\r
   6 #include <linux/kernel.h>\r
   7 #include <linux/module.h>\r
   8 #include <linux/interrupt.h>\r
   9 #include <linux/gpio.h>\r
  10 #include <linux/delay.h>\r
  11 #include <linux/irq.h>\r
  12 #include <linux/preempt.h>\r
  13 \r
  14 #include <asm/gpio.h>\r
  15 #include <asm/io.h>\r
  16 \r
  17 #include "mcs8000_download.h"\r
  18 \r
  19 \r
  20 //============================================================\r
  21 //\r
  22 //      Include MELFAS Binary code File ( ex> MELFAS_FIRM_bin.c)\r
  23 //\r
  24 //      Warning!!!!\r
  25 //              Please, don't add binary.c file into project\r
  26 //              Just #include here !!\r
  27 //\r
  28 //============================================================\r
  29 \r
  30 #include "master_bin.c"\r
  31 \r
  32 \r
  33 UINT8  ucVerifyBuffer[MELFAS_TRANSFER_LENGTH];          //      You may melloc *ucVerifyBuffer instead of this\r
  34 \r
  35 \r
  36 //---------------------------------\r
  37 //      Downloading functions\r
  38 //---------------------------------\r
  39 static int  mcsdl_download(const UINT8 *pData, const UINT16 nLength, INT8 IdxNum);\r
  40 static void mcsdl_set_ready(void);\r
  41 static void mcsdl_reboot_mcs(void);\r
  42 static int  mcsdl_erase_flash(INT8 IdxNum);\r
  43 static int  mcsdl_program_flash(UINT8 *pDataOriginal, UINT16 unLength, INT8 IdxNum);\r
  44 static void mcsdl_program_flash_part(UINT8 *pData);\r
  45 static int  mcsdl_verify_flash(UINT8 *pData, UINT16 nLength, INT8 IdxNum);\r
  46 static void mcsdl_read_flash(UINT8 *pBuffer);\r
  47 static int  mcsdl_read_flash_from(UINT8 *pBuffer, UINT16 unStart_addr, UINT16 unLength, INT8 IdxNum);\r
  48 static void mcsdl_select_isp_mode(UINT8 ucMode);\r
  49 static void mcsdl_unselect_isp_mode(void);\r
  50 static void mcsdl_read_32bits(UINT8 *pData);\r
  51 static void mcsdl_write_bits(UINT32 wordData, int nBits);\r
  52 static void mcsdl_scl_toggle_twice(void);\r
  53 //---------------------------------\r
  54 //      Delay functions\r
  55 //---------------------------------\r
  56 static void mcsdl_delay(UINT32 nCount);\r
  57 //---------------------------------\r
  58 //      For debugging display\r
  59 //---------------------------------\r
  60 #if MELFAS_ENABLE_DBG_PRINT\r
  61 static void mcsdl_print_result(int nRet);\r
  62 #endif\r
  63 //----------------------------------\r
  64 // Download enable command\r
  65 //----------------------------------\r
  66 #if MELFAS_USE_PROTOCOL_COMMAND_FOR_DOWNLOAD\r
  67 void melfas_send_download_enable_command(void)\r
  68 {\r
  69     // TO DO : Fill this up\r
  70 }\r
  71 #endif\r
  72 \r
  73 \r
  74 //============================================================\r
  75 //\r
  76 //      Main Download furnction\r
  77 //\r
  78 //   1. Run mcsdl_download( pBinary[IdxNum], nBinary_length[IdxNum], IdxNum);\r
  79 //       IdxNum : 0 (Master Chip Download)\r
  80 //       IdxNum : 1 (2Chip Download)\r
  81 //\r
  82 //\r
  83 //============================================================\r
  84 \r
  85 int mcsdl_download_binary_data(void)\r
  86 {\r
  87     int nRet;\r
  88 \r
  89         /* code for samsung */\r
  90         MCSDL_RESETB_SET_OUTPUT(0);\r
  91         MCSDL_GPIO_SDA_SET_LOW();\r
  92         MCSDL_GPIO_SCL_SET_LOW();\r
  93         MCSDL_RESETB_SET_LOW();\r
  94 \r
  95 #if MELFAS_USE_PROTOCOL_COMMAND_FOR_DOWNLOAD\r
  96     melfas_send_download_enable_command();\r
  97     mcsdl_delay(MCSDL_DELAY_100US);\r
  98 #endif\r
  99 \r
 100     MELFAS_DISABLE_BASEBAND_ISR();                                      // Disable Baseband touch interrupt ISR.\r
 101     MELFAS_DISABLE_WATCHDOG_TIMER_RESET();                      // Disable Baseband watchdog timer\r
 102 \r
 103     //------------------------\r
 104     // Run Download\r
 105     //------------------------\r
 106     nRet = mcsdl_download((const UINT8*) MELFAS_binary, (const UINT16)MELFAS_binary_nLength , 0);\r
 107 #if MELFAS_2CHIP_DOWNLOAD_ENABLE\r
 108     nRet = mcsdl_download((const UINT8*) MELFAS_binary_2, (const UINT16)MELFAS_binary_nLength_2, 1);  // Slave Binary data download\r
 109 #endif\r
 110     MELFAS_ROLLBACK_BASEBAND_ISR();                                     // Roll-back Baseband touch interrupt ISR.\r
 111     MELFAS_ROLLBACK_WATCHDOG_TIMER_RESET();                     // Roll-back Baseband watchdog timer\r
 112 \r
 113     return (nRet == MCSDL_RET_SUCCESS);\r
 114 }\r
 115 \r
 116 \r
 117 \r
 118 int mcsdl_download_binary_file(void)\r
 119 {\r
 120     int nRet;\r
 121     int i;\r
 122 \r
 123     UINT8  *pBinary[2] = {NULL, NULL};\r
 124     UINT16 nBinary_length[2] = {0, 0};\r
 125     UINT8 IdxNum = MELFAS_2CHIP_DOWNLOAD_ENABLE;\r
 126     //==================================================\r
 127     //\r
 128     //  1. Read '.bin file'\r
 129     //   2. *pBinary[0]       : Binary data(Master)\r
 130     //       *pBinary[1]       : Binary data(Slave)\r
 131     //     nBinary_length[0] : Firmware size(Master)\r
 132     //     nBinary_length[1] : Firmware size(Slave)\r
 133     //  3. Run mcsdl_download( pBinary[IdxNum], nBinary_length[IdxNum], IdxNum);\r
 134     //       IdxNum : 0 (Master Chip Download)\r
 135     //       IdxNum : 1 (2Chip Download)\r
 136     //\r
 137     //==================================================\r
 138 \r
 139 #if 0\r
 140 \r
 141     // TO DO : File Process & Get file Size(== Binary size)\r
 142     //                  This is just a simple sample\r
 143 \r
 144     FILE *fp;\r
 145     INT  nRead;\r
 146 \r
 147     //------------------------------\r
 148     // Open a file\r
 149     //------------------------------\r
 150 \r
 151     if (fopen(fp, "MELFAS_FIRMWARE.bin", "rb") == NULL)\r
 152     {\r
 153         return MCSDL_RET_FILE_ACCESS_FAILED;\r
 154     }\r
 155 \r
 156     //------------------------------\r
 157     // Get Binary Size\r
 158     //------------------------------\r
 159 \r
 160     fseek(fp, 0, SEEK_END);\r
 161 \r
 162     nBinary_length = (UINT16)ftell(fp);\r
 163 \r
 164     //------------------------------\r
 165     // Memory allocation\r
 166     //------------------------------\r
 167 \r
 168     pBinary = (UINT8*)malloc((INT)nBinary_length);\r
 169 \r
 170     if (pBinary == NULL)\r
 171     {\r
 172 \r
 173         return MCSDL_RET_FILE_ACCESS_FAILED;\r
 174     }\r
 175 \r
 176     //------------------------------\r
 177     // Read binary file\r
 178     //------------------------------\r
 179 \r
 180     fseek(fp, 0, SEEK_SET);\r
 181 \r
 182     nRead = fread(pBinary, 1, (INT)nBinary_length, fp);         // Read binary file\r
 183 \r
 184     if (nRead != (INT)nBinary_length)\r
 185     {\r
 186 \r
 187         fclose(fp);                                                                                             // Close file\r
 188 \r
 189         if (pBinary != NULL)                                                                            // free memory alloced.\r
 190             free(pBinary);\r
 191 \r
 192         return MCSDL_RET_FILE_ACCESS_FAILED;\r
 193     }\r
 194 \r
 195     //------------------------------\r
 196     // Close file\r
 197     //------------------------------\r
 198 \r
 199     fclose(fp);\r
 200 \r
 201 #endif\r
 202 \r
 203 #if MELFAS_USE_PROTOCOL_COMMAND_FOR_DOWNLOAD\r
 204     melfas_send_download_enable_command();\r
 205     mcsdl_delay(MCSDL_DELAY_100US);\r
 206 #endif\r
 207 \r
 208     MELFAS_DISABLE_BASEBAND_ISR();                  // Disable Baseband touch interrupt ISR.\r
 209     MELFAS_DISABLE_WATCHDOG_TIMER_RESET();          // Disable Baseband watchdog timer\r
 210 \r
 211     for (i = 0;i <= IdxNum;i++)\r
 212     {\r
 213         if (pBinary[i] != NULL && nBinary_length[i] > 0 && nBinary_length[i] < 32*1024)\r
 214         {\r
 215             //------------------------\r
 216             // Run Download\r
 217             //------------------------\r
 218             nRet = mcsdl_download((const UINT8 *)pBinary[i], (const UINT16)nBinary_length[i], i);\r
 219         }\r
 220         else\r
 221         {\r
 222             nRet = MCSDL_RET_WRONG_BINARY;\r
 223         }\r
 224     }\r
 225 \r
 226     MELFAS_ROLLBACK_BASEBAND_ISR();                 // Roll-back Baseband touch interrupt ISR.\r
 227     MELFAS_ROLLBACK_WATCHDOG_TIMER_RESET();         // Roll-back Baseband watchdog timer\r
 228 \r
 229 #if MELFAS_ENABLE_DBG_PRINT\r
 230     mcsdl_print_result(nRet);\r
 231 #endif\r
 232 \r
 233     return (nRet == MCSDL_RET_SUCCESS);\r
 234 }\r
 235 \r
 236 //------------------------------------------------------------------\r
 237 //\r
 238 //      Download function\r
 239 //\r
 240 //------------------------------------------------------------------\r
 241 \r
 242 static int mcsdl_download(const UINT8 *pBianry, const UINT16 unLength, INT8 IdxNum)\r
 243 {\r
 244     int i;\r
 245     int nRet;\r
 246 \r
 247     UINT8 Check_IC = 0xFF;  // d.model\r
 248     UINT8 readBuffer[32];\r
 249     UINT8 writeBuffer[4];\r
 250     UINT32 wordData;\r
 251 \r
 252     //---------------------------------\r
 253     // Check Binary Size\r
 254     //---------------------------------\r
 255     if (unLength >= MELFAS_FIRMWARE_MAX_SIZE)\r
 256     {\r
 257         nRet = MCSDL_RET_PROGRAM_SIZE_IS_WRONG;\r
 258         goto MCSDL_DOWNLOAD_FINISH;\r
 259     }\r
 260 \r
 261 \r
 262 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 263     printk(" - Starting download...\n");\r
 264 #endif\r
 265 \r
 266     //---------------------------------\r
 267     // Make it ready\r
 268     //---------------------------------\r
 269 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 270     printk(" > Ready\n");\r
 271 #endif\r
 272     mcsdl_set_ready();\r
 273 \r
 274     mcsdl_delay(MCSDL_DELAY_1MS);\r
 275     //--------------------------------------------------------------\r
 276     // IC Information read from Flash\r
 277     //--------------------------------------------------------------\r
 278 #if 1\r
 279     if (IdxNum == 0)\r
 280     {\r
 281         mcsdl_select_isp_mode(ISP_MODE_SERIAL_READ);\r
 282 \r
 283         wordData   = ((0x1F00 & 0x1FFF) << 1) | 0x0;\r
 284         wordData <<= 14;\r
 285         mcsdl_write_bits(wordData, 18);\r
 286 \r
 287         mcsdl_read_flash(readBuffer);\r
 288         MCSDL_GPIO_SDA_SET_LOW();\r
 289         MCSDL_GPIO_SDA_SET_OUTPUT(0);\r
 290 \r
 291         mcsdl_unselect_isp_mode();\r
 292 \r
 293         //if (readBuffer[3] != 0xFF)\r
 294         Check_IC = readBuffer[3];\r
 295 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 296         printk("\IC Information :0x%02X,  0x%02X\n", readBuffer[3], Check_IC);\r
 297 #endif\r
 298         mcsdl_delay(MCSDL_DELAY_1MS);\r
 299     }\r
 300 #endif\r
 301 \r
 302     //---------------------------------\r
 303     // Erase Flash\r
 304     //---------------------------------\r
 305 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 306     printk(" > Erase\n");\r
 307 #endif\r
 308 \r
 309         preempt_disable();\r
 310     nRet = mcsdl_erase_flash(IdxNum);\r
 311         preempt_enable();\r
 312 \r
 313     if (nRet != MCSDL_RET_SUCCESS)\r
 314         goto MCSDL_DOWNLOAD_FINISH;\r
 315 \r
 316 #if 1\r
 317     mcsdl_delay(MCSDL_DELAY_1MS);\r
 318     //--------------------------------------------------------------\r
 319     // IC Information write\r
 320     //--------------------------------------------------------------\r
 321     if (IdxNum == 0)\r
 322     {\r
 323         mcsdl_select_isp_mode(ISP_MODE_SERIAL_WRITE);\r
 324 \r
 325         wordData = ((0x1F00 & 0x1FFF) << 1) | 0x0 ;\r
 326         wordData = wordData << 14;\r
 327         mcsdl_write_bits(wordData, 18);\r
 328 \r
 329         writeBuffer[0] = Check_IC;\r
 330         writeBuffer[1] = 0xFF;\r
 331         writeBuffer[2] = 0xFF;\r
 332         writeBuffer[3] = 0xFF;\r
 333         mcsdl_program_flash_part(writeBuffer);\r
 334         //---------------------------------------------\r
 335         //      Tail\r
 336         //---------------------------------------------\r
 337         MCSDL_GPIO_SDA_SET_HIGH();\r
 338         mcsdl_delay(MCSDL_DELAY_40US);\r
 339 \r
 340         for (i = 0; i < 6; i++)\r
 341         {\r
 342             if (i == 2)\r
 343             {\r
 344                 mcsdl_delay(MCSDL_DELAY_20US);\r
 345             }\r
 346             else if (i == 3)\r
 347             {\r
 348                 mcsdl_delay(MCSDL_DELAY_40US);\r
 349             }\r
 350 \r
 351             MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_10US);\r
 352             MCSDL_GPIO_SCL_SET_LOW();   mcsdl_delay(MCSDL_DELAY_10US);\r
 353         }\r
 354         MCSDL_GPIO_SDA_SET_LOW();\r
 355 \r
 356         mcsdl_unselect_isp_mode();\r
 357         mcsdl_delay(MCSDL_DELAY_1MS);\r
 358     }\r
 359 #endif\r
 360 \r
 361     //---------------------------------\r
 362     // Program Flash\r
 363     //---------------------------------\r
 364 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 365     printk(" > Program   ");\r
 366 #endif\r
 367 \r
 368         preempt_disable();\r
 369     nRet = mcsdl_program_flash((UINT8*)pBianry, (UINT16)unLength, IdxNum);\r
 370         preempt_enable();\r
 371 \r
 372     if (nRet != MCSDL_RET_SUCCESS)\r
 373         goto MCSDL_DOWNLOAD_FINISH;\r
 374 \r
 375     mcsdl_delay(MCSDL_DELAY_1MS);\r
 376     //---------------------------------\r
 377     // Verify flash\r
 378     //---------------------------------\r
 379 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 380     printk(" > Verify    ");\r
 381 #endif\r
 382 \r
 383         preempt_disable();\r
 384     nRet = mcsdl_verify_flash((UINT8*)pBianry, (UINT16)unLength, IdxNum);\r
 385         preempt_enable();\r
 386 \r
 387     if (nRet != MCSDL_RET_SUCCESS)\r
 388         goto MCSDL_DOWNLOAD_FINISH;\r
 389 \r
 390 \r
 391     mcsdl_delay(MCSDL_DELAY_1MS);\r
 392     nRet = MCSDL_RET_SUCCESS;\r
 393 \r
 394 \r
 395 MCSDL_DOWNLOAD_FINISH :\r
 396 \r
 397 #if MELFAS_ENABLE_DBG_PRINT\r
 398     mcsdl_print_result(nRet);                                                           // Show result\r
 399 #endif\r
 400 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 401     printk(" > Rebooting\n");\r
 402     printk(" - Fin.\n\n");\r
 403 #endif\r
 404     mcsdl_reboot_mcs();\r
 405 \r
 406     return nRet;\r
 407 }\r
 408 \r
 409 \r
 410 \r
 411 //------------------------------------------------------------------\r
 412 //\r
 413 //      Sub functions\r
 414 //\r
 415 //------------------------------------------------------------------\r
 416 static int mcsdl_erase_flash(INT8 IdxNum)\r
 417 {\r
 418     int   i;\r
 419     UINT8 readBuffer[32];\r
 420     int eraseCompareValue = 0xFF;\r
 421     //----------------------------------------\r
 422     //  Do erase\r
 423     //----------------------------------------\r
 424     if (IdxNum > 0)\r
 425     {\r
 426         mcsdl_select_isp_mode(ISP_MODE_NEXT_CHIP_BYPASS);\r
 427         mcsdl_delay(MCSDL_DELAY_3US);\r
 428     }\r
 429     mcsdl_select_isp_mode(ISP_MODE_ERASE_FLASH);\r
 430     mcsdl_unselect_isp_mode();\r
 431 \r
 432 \r
 433     //----------------------------------------\r
 434     //  Check 'erased well'\r
 435     //----------------------------------------\r
 436 #if 0\r
 437     mcsdl_read_flash_from(readBuffer, 0x0000, 16, IdxNum);\r
 438     mcsdl_read_flash_from(&readBuffer[16], 0x7FF0, 16, IdxNum);\r
 439 \r
 440     // Compare with '0xFF'\r
 441     if (IdxNum > 0)\r
 442     {\r
 443         eraseCompareValue = 0x00;\r
 444     }\r
 445     for (i = 0; i < 32; i++)\r
 446     {\r
 447         if (readBuffer[i] != eraseCompareValue)\r
 448             return MCSDL_RET_ERASE_FLASH_VERIFY_FAILED;\r
 449     }\r
 450 #endif\r
 451 \r
 452     return MCSDL_RET_SUCCESS;\r
 453 }\r
 454 \r
 455 \r
 456 static int mcsdl_program_flash(UINT8 *pDataOriginal, UINT16 unLength, INT8 IdxNum)\r
 457 {\r
 458     int         i;\r
 459 \r
 460     UINT8       *pData;\r
 461     UINT8   ucLength;\r
 462 \r
 463     UINT16  addr;\r
 464     UINT32  header;\r
 465 \r
 466     addr   = 0;\r
 467     pData  = pDataOriginal;\r
 468     ucLength = MELFAS_TRANSFER_LENGTH;\r
 469 \r
 470     while ((addr*4) < (int)unLength)\r
 471     {\r
 472         if ((unLength - (addr*4)) < MELFAS_TRANSFER_LENGTH)\r
 473         {\r
 474             ucLength  = (UINT8)(unLength - (addr * 4));\r
 475         }\r
 476 \r
 477         //--------------------------------------\r
 478         //      Select ISP Mode\r
 479         //--------------------------------------\r
 480         mcsdl_delay(MCSDL_DELAY_40US);\r
 481         if (IdxNum > 0)\r
 482         {\r
 483             mcsdl_select_isp_mode(ISP_MODE_NEXT_CHIP_BYPASS);\r
 484             mcsdl_delay(MCSDL_DELAY_3US);\r
 485         }\r
 486         mcsdl_select_isp_mode(ISP_MODE_SERIAL_WRITE);\r
 487 \r
 488         //---------------------------------------------\r
 489         //      Header\r
 490         //      Address[13ibts] <<1\r
 491         //---------------------------------------------\r
 492         header = ((addr & 0x1FFF) << 1) | 0x0 ;\r
 493         header = header << 14;\r
 494         mcsdl_write_bits(header, 18); //Write 18bits\r
 495 \r
 496         //---------------------------------\r
 497         //      Writing\r
 498         //---------------------------------\r
 499         //addr += (UINT16)ucLength;\r
 500         addr += 1;\r
 501 \r
 502 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 503         printk("#");\r
 504 #endif\r
 505         mcsdl_program_flash_part(pData);\r
 506         pData  += ucLength;\r
 507 \r
 508         //---------------------------------------------\r
 509         //      Tail\r
 510         //---------------------------------------------\r
 511         MCSDL_GPIO_SDA_SET_HIGH();\r
 512         mcsdl_delay(MCSDL_DELAY_40US);\r
 513 \r
 514         for (i = 0; i < 6; i++)\r
 515         {\r
 516             if (i == 2)\r
 517             {\r
 518                 mcsdl_delay(MCSDL_DELAY_20US);\r
 519             }\r
 520             else if (i == 3)\r
 521             {\r
 522                 mcsdl_delay(MCSDL_DELAY_40US);\r
 523             }\r
 524 \r
 525             MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_10US);\r
 526             MCSDL_GPIO_SCL_SET_LOW();   mcsdl_delay(MCSDL_DELAY_10US);\r
 527         }\r
 528         MCSDL_GPIO_SDA_SET_LOW();\r
 529 \r
 530         mcsdl_unselect_isp_mode();\r
 531         mcsdl_delay(MCSDL_DELAY_300US);\r
 532     }\r
 533 \r
 534     return MCSDL_RET_SUCCESS;\r
 535 }\r
 536 \r
 537 static void mcsdl_program_flash_part(UINT8 *pData)\r
 538 {\r
 539     int     i;\r
 540     UINT32      data;\r
 541 \r
 542 \r
 543     //---------------------------------\r
 544     //  Body\r
 545     //---------------------------------\r
 546     data  = (UINT32)pData[0] <<  0;\r
 547     data |= (UINT32)pData[1] <<  8;\r
 548     data |= (UINT32)pData[2] << 16;\r
 549     data |= (UINT32)pData[3] << 24;\r
 550     mcsdl_write_bits(data, 32);\r
 551 }\r
 552 \r
 553 static int mcsdl_verify_flash(UINT8 *pDataOriginal, UINT16 unLength, INT8 IdxNum)\r
 554 {\r
 555     int   i, j;\r
 556     int   nRet;\r
 557 \r
 558     UINT8 *pData;\r
 559     UINT8 ucLength;\r
 560 \r
 561     UINT16 addr;\r
 562     UINT32 wordData;\r
 563 \r
 564     addr  = 0;\r
 565     pData = (UINT8 *) pDataOriginal;\r
 566     ucLength  = MELFAS_TRANSFER_LENGTH;\r
 567 \r
 568     while ((addr*4) < (int)unLength)\r
 569     {\r
 570         if ((unLength - (addr*4)) < MELFAS_TRANSFER_LENGTH)\r
 571         {\r
 572             ucLength = (UINT8)(unLength - (addr * 4));\r
 573         }\r
 574         // start ADD DELAY\r
 575         mcsdl_delay(MCSDL_DELAY_40US);\r
 576 \r
 577         //--------------------------------------\r
 578         //      Select ISP Mode\r
 579         //--------------------------------------\r
 580         if (IdxNum > 0)\r
 581         {\r
 582             mcsdl_select_isp_mode(ISP_MODE_NEXT_CHIP_BYPASS);\r
 583             mcsdl_delay(MCSDL_DELAY_3US);\r
 584         }\r
 585         mcsdl_select_isp_mode(ISP_MODE_SERIAL_READ);\r
 586 \r
 587 \r
 588         //---------------------------------------------\r
 589         //      Header\r
 590         //      Address[13ibts] <<1\r
 591         //---------------------------------------------\r
 592         wordData   = ((addr & 0x1FFF) << 1) | 0x0;\r
 593         wordData <<= 14;\r
 594         mcsdl_write_bits(wordData, 18);\r
 595         addr += 1;\r
 596 \r
 597 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 598         printk("#");\r
 599 #endif\r
 600 \r
 601         //--------------------\r
 602         // Read flash\r
 603         //--------------------\r
 604         mcsdl_read_flash(ucVerifyBuffer);\r
 605 \r
 606         MCSDL_GPIO_SDA_SET_LOW();\r
 607         MCSDL_GPIO_SDA_SET_OUTPUT(0);\r
 608 \r
 609         //--------------------\r
 610         // Comparing\r
 611         //--------------------\r
 612         if (IdxNum == 0)\r
 613         {\r
 614             for (j = 0; j < (int)ucLength; j++)\r
 615             {\r
 616 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 617                 printk(" %02X", ucVerifyBuffer[j]);\r
 618 #endif\r
 619                 if (ucVerifyBuffer[j] != pData[j])\r
 620                 {\r
 621 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 622                     printk("\n [Error] Address : 0x%04X : 0x%02X - 0x%02X\n", addr, pData[j], ucVerifyBuffer[j]);\r
 623 #endif\r
 624                     nRet = MCSDL_RET_PROGRAM_VERIFY_FAILED;\r
 625                     goto MCSDL_VERIFY_FLASH_FINISH;\r
 626                 }\r
 627             }\r
 628         }\r
 629         else // slave\r
 630         {\r
 631             for (j = 0; j < (int)ucLength; j++)\r
 632             {\r
 633 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 634                 printk(" %02X", ucVerifyBuffer[j]);\r
 635 #endif\r
 636                 if ((0xff - ucVerifyBuffer[j]) != pData[j])\r
 637                 {\r
 638 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 639                     printk("\n [Error] Address : 0x%04X : 0x%02X - 0x%02X\n", addr, pData[j], ucVerifyBuffer[j]);\r
 640 #endif\r
 641                     nRet = MCSDL_RET_PROGRAM_VERIFY_FAILED;\r
 642                     goto MCSDL_VERIFY_FLASH_FINISH;\r
 643                 }\r
 644             }\r
 645         }\r
 646         pData += ucLength;\r
 647         mcsdl_unselect_isp_mode();\r
 648     }\r
 649 \r
 650     nRet = MCSDL_RET_SUCCESS;\r
 651 \r
 652 MCSDL_VERIFY_FLASH_FINISH:\r
 653 \r
 654 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 655     printk("\n");\r
 656 #endif\r
 657 \r
 658     mcsdl_unselect_isp_mode();\r
 659     return nRet;\r
 660 }\r
 661 \r
 662 \r
 663 static void mcsdl_read_flash(UINT8 *pBuffer)\r
 664 {\r
 665     int i;\r
 666 \r
 667     MCSDL_GPIO_SCL_SET_LOW();\r
 668     MCSDL_GPIO_SDA_SET_LOW();\r
 669     mcsdl_delay(MCSDL_DELAY_40US);\r
 670 \r
 671     for (i = 0; i < 6; i++)\r
 672     {\r
 673         MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_10US);\r
 674         MCSDL_GPIO_SCL_SET_LOW();  mcsdl_delay(MCSDL_DELAY_10US);\r
 675     }\r
 676 \r
 677     mcsdl_read_32bits(pBuffer);\r
 678 }\r
 679 \r
 680 static int mcsdl_read_flash_from(UINT8 *pBuffer, UINT16 unStart_addr, UINT16 unLength, INT8 IdxNum)\r
 681 {\r
 682     int i;\r
 683     int j;\r
 684 \r
 685     UINT8  ucLength;\r
 686 \r
 687     UINT16 addr;\r
 688     UINT32 wordData;\r
 689 \r
 690     if (unLength >= MELFAS_FIRMWARE_MAX_SIZE)\r
 691     {\r
 692         return MCSDL_RET_PROGRAM_SIZE_IS_WRONG;\r
 693     }\r
 694 \r
 695     addr  = 0;\r
 696     ucLength  = MELFAS_TRANSFER_LENGTH;\r
 697 \r
 698 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 699     printk(" %04X : ", unStart_addr);\r
 700 #endif\r
 701 \r
 702 \r
 703     for (i = 0; i < (int)unLength; i += (int)ucLength)\r
 704     {\r
 705 \r
 706         addr = (UINT16)i;\r
 707         if (IdxNum > 0)\r
 708         {\r
 709             mcsdl_select_isp_mode(ISP_MODE_NEXT_CHIP_BYPASS);\r
 710             mcsdl_delay(MCSDL_DELAY_3US);\r
 711         }\r
 712 \r
 713         mcsdl_select_isp_mode(ISP_MODE_SERIAL_READ);\r
 714         wordData   = (((unStart_addr + addr) & 0x1FFF) << 1) | 0x0;\r
 715         wordData <<= 14;\r
 716 \r
 717         mcsdl_write_bits(wordData, 18);\r
 718         if ((unLength - addr) < MELFAS_TRANSFER_LENGTH)\r
 719         {\r
 720             ucLength = (UINT8)(unLength - addr);\r
 721         }\r
 722 \r
 723         //--------------------\r
 724         // Read flash\r
 725         //--------------------\r
 726         mcsdl_read_flash(&pBuffer[addr]);\r
 727 \r
 728 #if MELFAS_ENABLE_DBG_PROGRESS_PRINT\r
 729         for (j = 0; j < (int)ucLength; j++)\r
 730         {\r
 731             printk("%02X ", pBuffer[j]);\r
 732         }\r
 733 #endif\r
 734 \r
 735         mcsdl_unselect_isp_mode();\r
 736     }\r
 737 \r
 738     return MCSDL_RET_SUCCESS;\r
 739 }\r
 740 \r
 741 \r
 742 static void mcsdl_set_ready(void)\r
 743 {\r
 744     //--------------------------------------------\r
 745     // Tkey module reset\r
 746     //--------------------------------------------\r
 747 \r
 748     MCSDL_VDD_SET_LOW(); // power\r
 749     //MCSDL_CE_SET_LOW();\r
 750     //MCSDL_CE_SET_OUTPUT();\r
 751 \r
 752     MCSDL_GPIO_SDA_SET_LOW();\r
 753     MCSDL_GPIO_SDA_SET_OUTPUT(0);\r
 754 \r
 755     MCSDL_GPIO_SCL_SET_LOW();\r
 756     MCSDL_GPIO_SCL_SET_OUTPUT(0);\r
 757 \r
 758     MCSDL_RESETB_SET_LOW();\r
 759     MCSDL_RESETB_SET_OUTPUT(0);\r
 760 \r
 761     mcsdl_delay(MCSDL_DELAY_25MS);                                              // Delay for Stable VDD\r
 762 \r
 763     MCSDL_VDD_SET_HIGH();\r
 764     //MCSDL_CE_SET_HIGH();\r
 765 \r
 766     MCSDL_GPIO_SCL_SET_LOW();\r
 767     MCSDL_GPIO_SDA_SET_HIGH();\r
 768     mcsdl_delay(MCSDL_DELAY_40MS);                                              // Delay '30 msec'\r
 769 }\r
 770 \r
 771 \r
 772 static void mcsdl_reboot_mcs(void)\r
 773 {\r
 774     MCSDL_VDD_SET_LOW();\r
 775     //MCSDL_CE_SET_LOW();\r
 776     //MCSDL_CE_SET_OUTPUT();\r
 777 \r
 778     MCSDL_GPIO_SDA_SET_HIGH();\r
 779     MCSDL_GPIO_SDA_SET_OUTPUT(1);\r
 780 \r
 781     MCSDL_GPIO_SCL_SET_HIGH();\r
 782     MCSDL_GPIO_SCL_SET_OUTPUT(1);\r
 783 \r
 784     MCSDL_RESETB_SET_LOW();\r
 785     MCSDL_RESETB_SET_OUTPUT(0);\r
 786 \r
 787     mcsdl_delay(MCSDL_DELAY_25MS);                                              // Delay for Stable VDD\r
 788 \r
 789     MCSDL_VDD_SET_HIGH();\r
 790     //MCSDL_CE_SET_HIGH();\r
 791 \r
 792     MCSDL_RESETB_SET_HIGH();\r
 793     MCSDL_RESETB_SET_INPUT();\r
 794     MCSDL_GPIO_SCL_SET_INPUT();\r
 795     MCSDL_GPIO_SDA_SET_INPUT();\r
 796 \r
 797     mcsdl_delay(MCSDL_DELAY_30MS);                                              // Delay '25 msec'\r
 798 }\r
 799 \r
 800 \r
 801 //--------------------------------------------\r
 802 //\r
 803 //   Write ISP Mode entering signal\r
 804 //\r
 805 //--------------------------------------------\r
 806 static void mcsdl_select_isp_mode(UINT8 ucMode)\r
 807 {\r
 808     int    i;\r
 809 \r
 810     UINT8 enteringCodeMassErase[16]   = { 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1 };\r
 811     UINT8 enteringCodeSerialWrite[16] = { 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1 };\r
 812     UINT8 enteringCodeSerialRead[16]  = { 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1 };\r
 813     UINT8 enteringCodeNextChipBypass[16]  = { 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1 };\r
 814 \r
 815     UINT8 *pCode;\r
 816 \r
 817 \r
 818     //------------------------------------\r
 819     // Entering ISP mode : Part 1\r
 820     //------------------------------------\r
 821     if (ucMode == ISP_MODE_ERASE_FLASH) pCode = enteringCodeMassErase;\r
 822     else if (ucMode == ISP_MODE_SERIAL_WRITE) pCode = enteringCodeSerialWrite;\r
 823     else if (ucMode == ISP_MODE_SERIAL_READ) pCode = enteringCodeSerialRead;\r
 824     else if (ucMode == ISP_MODE_NEXT_CHIP_BYPASS) pCode = enteringCodeNextChipBypass;\r
 825 \r
 826     MCSDL_RESETB_SET_LOW();\r
 827     MCSDL_GPIO_SCL_SET_LOW();\r
 828     MCSDL_GPIO_SDA_SET_HIGH();\r
 829 \r
 830     for (i = 0; i < 16; i++)\r
 831     {\r
 832         if (pCode[i] == 1)\r
 833             MCSDL_RESETB_SET_HIGH();\r
 834         else\r
 835             MCSDL_RESETB_SET_LOW();\r
 836 \r
 837         mcsdl_delay(MCSDL_DELAY_3US);\r
 838         MCSDL_GPIO_SCL_SET_HIGH();      mcsdl_delay(MCSDL_DELAY_3US);\r
 839         MCSDL_GPIO_SCL_SET_LOW();       mcsdl_delay(MCSDL_DELAY_3US);\r
 840     }\r
 841 \r
 842     MCSDL_RESETB_SET_LOW();\r
 843 \r
 844     //---------------------------------------------------\r
 845     // Entering ISP mode : Part 2       - Only Mass Erase\r
 846     //---------------------------------------------------\r
 847     mcsdl_delay(MCSDL_DELAY_7US);\r
 848 \r
 849     MCSDL_GPIO_SCL_SET_LOW();\r
 850     MCSDL_GPIO_SDA_SET_HIGH();\r
 851     if (ucMode == ISP_MODE_ERASE_FLASH)\r
 852     {\r
 853         mcsdl_delay(MCSDL_DELAY_7US);\r
 854         for (i = 0; i < 4; i++)\r
 855         {\r
 856             if (i == 2) mcsdl_delay(MCSDL_DELAY_25MS);\r
 857             else if (i == 3) mcsdl_delay(MCSDL_DELAY_150US);\r
 858 \r
 859             MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_3US);\r
 860             MCSDL_GPIO_SCL_SET_LOW();   mcsdl_delay(MCSDL_DELAY_7US);\r
 861         }\r
 862     }\r
 863     MCSDL_GPIO_SDA_SET_LOW();\r
 864 }\r
 865 \r
 866 \r
 867 static void mcsdl_unselect_isp_mode(void)\r
 868 {\r
 869     int i;\r
 870 \r
 871     MCSDL_RESETB_SET_LOW();\r
 872     mcsdl_delay(MCSDL_DELAY_3US);\r
 873 \r
 874     for (i = 0; i < 10; i++)\r
 875     {\r
 876         MCSDL_GPIO_SCL_SET_HIGH();      mcsdl_delay(MCSDL_DELAY_3US);\r
 877         MCSDL_GPIO_SCL_SET_LOW();       mcsdl_delay(MCSDL_DELAY_3US);\r
 878     }\r
 879 }\r
 880 \r
 881 \r
 882 \r
 883 static void mcsdl_read_32bits(UINT8 *pData)\r
 884 {\r
 885     int i, j;\r
 886 \r
 887     MCSDL_GPIO_SCL_SET_LOW();\r
 888     MCSDL_GPIO_SDA_SET_LOW();\r
 889 \r
 890     MCSDL_GPIO_SDA_SET_INPUT();\r
 891 \r
 892     for (i = 3; i >= 0; i--)\r
 893     {\r
 894         pData[i] = 0;\r
 895         for (j = 0; j < 8; j++)\r
 896         {\r
 897             pData[i] <<= 1;\r
 898 \r
 899             MCSDL_GPIO_SCL_SET_LOW();   mcsdl_delay(MCSDL_DELAY_1US);\r
 900             MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_1US);\r
 901 \r
 902             if (MCSDL_GPIO_SDA_IS_HIGH())\r
 903                 pData[i] |= 0x01;\r
 904         }\r
 905     }\r
 906     \r
 907     MCSDL_GPIO_SDA_SET_LOW();\r
 908     MCSDL_GPIO_SDA_SET_OUTPUT(0);\r
 909 }\r
 910 \r
 911 \r
 912 \r
 913 static void mcsdl_write_bits(UINT32 wordData, int nBits)\r
 914 {\r
 915     int i;\r
 916 \r
 917     MCSDL_GPIO_SCL_SET_LOW();\r
 918     MCSDL_GPIO_SDA_SET_LOW();\r
 919 \r
 920     for (i = 0; i < nBits; i++)\r
 921     {\r
 922         if (wordData & 0x80000000) {MCSDL_GPIO_SDA_SET_HIGH();}\r
 923         else                       {MCSDL_GPIO_SDA_SET_LOW();}\r
 924 \r
 925         mcsdl_delay(MCSDL_DELAY_3US);\r
 926         MCSDL_GPIO_SCL_SET_HIGH();              mcsdl_delay(MCSDL_DELAY_3US);\r
 927         MCSDL_GPIO_SCL_SET_LOW();               mcsdl_delay(MCSDL_DELAY_3US);\r
 928 \r
 929         wordData <<= 1;\r
 930     }\r
 931 }\r
 932 \r
 933 \r
 934 static void mcsdl_scl_toggle_twice(void)\r
 935 {\r
 936     MCSDL_GPIO_SDA_SET_HIGH();\r
 937     MCSDL_GPIO_SDA_SET_OUTPUT(1);\r
 938 \r
 939     MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_20US);\r
 940     MCSDL_GPIO_SCL_SET_LOW();   mcsdl_delay(MCSDL_DELAY_20US);\r
 941 \r
 942     MCSDL_GPIO_SCL_SET_HIGH();  mcsdl_delay(MCSDL_DELAY_20US);\r
 943     MCSDL_GPIO_SCL_SET_LOW();   mcsdl_delay(MCSDL_DELAY_20US);\r
 944 }\r
 945 \r
 946 \r
 947 //============================================================\r
 948 //\r
 949 //      Delay Function\r
 950 //\r
 951 //============================================================\r
 952 static void mcsdl_delay(UINT32 nCount)\r
 953 {\r
 954 \r
 955     switch (nCount)\r
 956     {\r
 957     case MCSDL_DELAY_1US   : {udelay(1);   break;}\r
 958     case MCSDL_DELAY_2US   : {udelay(2);   break;}\r
 959     case MCSDL_DELAY_3US   : {udelay(3);   break;}\r
 960     case MCSDL_DELAY_5US   : {udelay(5);   break;}\r
 961     case MCSDL_DELAY_7US   : {udelay(7);   break;}\r
 962     case MCSDL_DELAY_10US  : {udelay(10);  break;}\r
 963     case MCSDL_DELAY_15US  : {udelay(15);  break;}\r
 964     case MCSDL_DELAY_20US  : {udelay(20);  break;}\r
 965     case MCSDL_DELAY_40US  : {udelay(40);  break;}\r
 966     case MCSDL_DELAY_100US : {udelay(100); break;}\r
 967     case MCSDL_DELAY_150US : {udelay(150); break;}\r
 968     case MCSDL_DELAY_300US : {udelay(300); break;}\r
 969     case MCSDL_DELAY_500US : {udelay(500); break;}\r
 970     case MCSDL_DELAY_800US : {udelay(800); break;}\r
 971     case MCSDL_DELAY_1MS   : {mdelay(1);   break;}\r
 972     case MCSDL_DELAY_5MS   : {mdelay(5);   break;}\r
 973     case MCSDL_DELAY_10MS  : {mdelay(10);  break;}\r
 974     case MCSDL_DELAY_25MS  : {mdelay(25);  break;}\r
 975     case MCSDL_DELAY_30MS  : {mdelay(30);  break;}\r
 976     case MCSDL_DELAY_40MS  : {mdelay(40);  break;}\r
 977     case MCSDL_DELAY_45MS  : {mdelay(45);  break;}\r
 978     case MCSDL_DELAY_60MS  : {mdelay(60);  break;}\r
 979     default : {break;}\r
 980     }// Please, Use your delay function\r
 981 }\r
 982 \r
 983 \r
 984 \r
 985 //============================================================\r
 986 //\r
 987 //      Debugging print functions.\r
 988 //\r
 989 //============================================================\r
 990 \r
 991 #ifdef MELFAS_ENABLE_DBG_PRINT\r
 992 static void mcsdl_print_result(int nRet)\r
 993 {\r
 994     if (nRet == MCSDL_RET_SUCCESS)\r
 995     {\r
 996         printk(" > MELFAS Firmware downloading SUCCESS.\n");\r
 997     }\r
 998     else\r
 999     {\r
1000         printk(" > MELFAS Firmware downloading FAILED  :  ");\r
1001         switch (nRet)\r
1002         {\r
1003         case MCSDL_RET_SUCCESS                                  :   printk("MCSDL_RET_SUCCESS\n"); break;\r
1004         case MCSDL_RET_ERASE_FLASH_VERIFY_FAILED                :   printk("MCSDL_RET_ERASE_FLASH_VERIFY_FAILED\n"); break;\r
1005         case MCSDL_RET_PROGRAM_VERIFY_FAILED                    :   printk("MCSDL_RET_PROGRAM_VERIFY_FAILED\n"); break;\r
1006 \r
1007         case MCSDL_RET_PROGRAM_SIZE_IS_WRONG                    :   printk("MCSDL_RET_PROGRAM_SIZE_IS_WRONG\n"); break;\r
1008         case MCSDL_RET_VERIFY_SIZE_IS_WRONG                             :   printk("MCSDL_RET_VERIFY_SIZE_IS_WRONG\n"); break;\r
1009         case MCSDL_RET_WRONG_BINARY                                             :   printk("MCSDL_RET_WRONG_BINARY\n"); break;\r
1010 \r
1011         case MCSDL_RET_READING_HEXFILE_FAILED           :   printk("MCSDL_RET_READING_HEXFILE_FAILED\n"); break;\r
1012         case MCSDL_RET_FILE_ACCESS_FAILED                       :   printk("MCSDL_RET_FILE_ACCESS_FAILED\n"); break;\r
1013         case MCSDL_RET_MELLOC_FAILED                                    :   printk("MCSDL_RET_MELLOC_FAILED\n"); break;\r
1014 \r
1015         case MCSDL_RET_WRONG_MODULE_REVISION                    :   printk("MCSDL_RET_WRONG_MODULE_REVISION\n"); break;\r
1016 \r
1017         default                                                 :       printk("UNKNOWN ERROR. [0x%02X].\n", nRet); break;\r
1018         }\r
1019 \r
1020         printk("\n");\r
1021     }\r
1022 }\r
1023 \r
1024 #endif\r
1025 \r
1026 \r
1027 #if MELFAS_ENABLE_DELAY_TEST\r
1028 \r
1029 //============================================================\r
1030 //\r
1031 //      For initial testing of delay and gpio control\r
1032 //\r
1033 //      You can confirm GPIO control and delay time by calling this function.\r
1034 //\r
1035 //============================================================\r
1036 \r
1037 void mcsdl_delay_test(INT32 nCount)\r
1038 {\r
1039     INT16 i;\r
1040 \r
1041     MELFAS_DISABLE_BASEBAND_ISR();                                      // Disable Baseband touch interrupt ISR.\r
1042     MELFAS_DISABLE_WATCHDOG_TIMER_RESET();                      // Disable Baseband watchdog timer\r
1043 \r
1044     //--------------------------------\r
1045     //  Repeating 'nCount' times\r
1046     //--------------------------------\r
1047 \r
1048     //MCSDL_SET_GPIO_I2C();\r
1049     MCSDL_GPIO_SCL_SET_OUTPUT(0);\r
1050     MCSDL_GPIO_SDA_SET_OUTPUT(0);\r
1051     MCSDL_RESETB_SET_OUTPUT(0);\r
1052 \r
1053     MCSDL_GPIO_SCL_SET_HIGH();\r
1054 \r
1055     for (i = 0; i < nCount; i++)\r
1056     {\r
1057 \r
1058 #if 1\r
1059 \r
1060         MCSDL_GPIO_SCL_SET_LOW();\r
1061 \r
1062         mcsdl_delay(MCSDL_DELAY_20US);\r
1063 \r
1064         MCSDL_GPIO_SCL_SET_HIGH();\r
1065 \r
1066         mcsdl_delay(MCSDL_DELAY_100US);\r
1067 #elif 0\r
1068 \r
1069         MCSDL_GPIO_SCL_SET_LOW();\r
1070 \r
1071         mcsdl_delay(MCSDL_DELAY_500US);\r
1072 \r
1073         MCSDL_GPIO_SCL_SET_HIGH();\r
1074 \r
1075         mcsdl_delay(MCSDL_DELAY_1MS);\r
1076 #else\r
1077 \r
1078         MCSDL_GPIO_SCL_SET_LOW();\r
1079 \r
1080         mcsdl_delay(MCSDL_DELAY_25MS);\r
1081 \r
1082         TKEY_INTR_SET_LOW();\r
1083 \r
1084         mcsdl_delay(MCSDL_DELAY_45MS);\r
1085 \r
1086         TKEY_INTR_SET_HIGH();\r
1087 #endif\r
1088     }\r
1089 \r
1090     MCSDL_GPIO_SCL_SET_HIGH();\r
1091 \r
1092     MELFAS_ROLLBACK_BASEBAND_ISR();                                     // Roll-back Baseband touch interrupt ISR.\r
1093     MELFAS_ROLLBACK_WATCHDOG_TIMER_RESET();                     // Roll-back Baseband watchdog timer\r
1094 }\r
1095 #endif\r
1096 \r
1097 \r
1098 \r