cvs.zerfleddert.de Git - proxmark3-svn/blob - armsrc/i2c.c

   1 //-----------------------------------------------------------------------------
   2 // Willok, June 2018
   3 // Edits by Iceman, July 2018
   4 //
   5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   6 // at your option, any later version. See the LICENSE.txt file for the text of
   7 // the license.
   8 //-----------------------------------------------------------------------------
   9 // The main i2c code, for communications with smart card module
  10 //-----------------------------------------------------------------------------
  11
  12 #include "i2c.h"
  13
  14 #include <stdint.h>
  15 #include <stdbool.h>
  16 #include "string.h"  //for memset memcmp
  17 #include "proxmark3.h"
  18 #include "mifareutil.h" // for MF_DBGLEVEL
  19 #include "BigBuf.h"
  20 #include "apps.h"
  21 #include "usb_cdc.h"
  22
  23 #ifdef WITH_SMARTCARD
  24 #include "smartcard.h"
  25 #endif
  26
  27
  28 #define GPIO_RST  AT91C_PIO_PA1
  29 #define GPIO_SCL  AT91C_PIO_PA5
  30 #define GPIO_SDA  AT91C_PIO_PA7
  31
  32 #define SCL_H   HIGH(GPIO_SCL)
  33 #define SCL_L   LOW(GPIO_SCL)
  34 #define SDA_H   HIGH(GPIO_SDA)
  35 #define SDA_L   LOW(GPIO_SDA)
  36
  37 #define SCL_read  (AT91C_BASE_PIOA->PIO_PDSR & GPIO_SCL)
  38 #define SDA_read  (AT91C_BASE_PIOA->PIO_PDSR & GPIO_SDA)
  39
  40 #define I2C_ERROR  "I2C_WaitAck Error"
  41
  42 static volatile unsigned long c;
  43
  44 //      Ö±½ÓÊ¹ÓÃÑ»·À´ÑÓÊ±£¬Ò»¸öÑ»· 6 ÌõÖ¸Áî£¬48M£¬ Delay=1 ´ó¸ÅÎª 200kbps
  45 // timer.
  46 // I2CSpinDelayClk(4) = 12.31us
  47 // I2CSpinDelayClk(1) = 3.07us
  48 static void __attribute__((optimize("O0"))) I2CSpinDelayClk(uint16_t delay) {
  49         for (c = delay * 2; c; c--) {};
  50 }
  51
  52 // communication delay functions
  53 #define I2C_DELAY_1CLK    I2CSpinDelayClk(1)
  54 #define I2C_DELAY_2CLK    I2CSpinDelayClk(2)
  55 #define I2C_DELAY_XCLK(x) I2CSpinDelayClk((x))
  56
  57 #define  ISO7618_MAX_FRAME 255
  58
  59 // try i2c bus recovery at 100kHz = 5uS high, 5uS low
  60 static void I2C_recovery(void) {
  61
  62         DbpString("Performing i2c bus recovery");
  63
  64         // reset I2C
  65         SDA_H; SCL_H;
  66
  67          //9nth cycle acts as NACK
  68         for (int i = 0; i < 10; i++)  {
  69                 SCL_H; WaitUS(5);
  70                 SCL_L; WaitUS(5);
  71         }
  72
  73     //a STOP signal (SDA from low to high while CLK is high)
  74         SDA_L; WaitUS(5);
  75         SCL_H; WaitUS(2);
  76         SDA_H; WaitUS(2);
  77
  78         bool isok = (SCL_read && SDA_read);
  79     if (!SDA_read)
  80                 DbpString("I2C bus recovery  error: SDA still LOW");
  81         if (!SCL_read)
  82                 DbpString("I2C bus recovery  error: SCL still LOW");
  83         if (isok)
  84                 DbpString("I2C bus recovery complete");
  85 }
  86
  87 static void I2C_init(void) {
  88         // Configure reset pin
  89         AT91C_BASE_PIOA->PIO_PPUDR = GPIO_RST;  // disable pull up resistor
  90         AT91C_BASE_PIOA->PIO_MDDR = GPIO_RST;   // push-pull output (multidriver disabled)
  91
  92         // Configure SCL and SDA pins
  93         AT91C_BASE_PIOA->PIO_PPUER |= (GPIO_SCL | GPIO_SDA);  // enable pull up resistor
  94         AT91C_BASE_PIOA->PIO_MDER |= (GPIO_SCL | GPIO_SDA);   // open drain output (multidriver enabled) - requires external pull up resistor
  95
  96         // set all three outputs to high
  97         AT91C_BASE_PIOA->PIO_SODR |= (GPIO_SCL | GPIO_SDA | GPIO_RST);
  98
  99         // configure all three pins as output, controlled by PIOA
 100         AT91C_BASE_PIOA->PIO_OER |= (GPIO_SCL | GPIO_SDA | GPIO_RST);
 101         AT91C_BASE_PIOA->PIO_PER |= (GPIO_SCL | GPIO_SDA | GPIO_RST);
 102
 103         bool isok =  (SCL_read && SDA_read);
 104         if ( !isok )
 105                 I2C_recovery();
 106
 107 }
 108
 109 // set the reset state
 110 static void I2C_SetResetStatus(uint8_t LineRST, uint8_t LineSCK, uint8_t LineSDA) {
 111         if (LineRST)
 112                 HIGH(GPIO_RST);
 113         else
 114                 LOW(GPIO_RST);
 115
 116         if (LineSCK)
 117                 HIGH(GPIO_SCL);
 118         else
 119                 LOW(GPIO_SCL);
 120
 121         if (LineSDA)
 122                 HIGH(GPIO_SDA);
 123         else
 124                 LOW(GPIO_SDA);
 125 }
 126
 127 // Reset the SIM_Adapter, then  enter the main program
 128 // Note: the SIM_Adapter will not enter the main program after power up. Please run this function before use SIM_Adapter.
 129 static void I2C_Reset_EnterMainProgram(void) {
 130         StartTicks();
 131         I2C_init();
 132         I2C_SetResetStatus(0, 0, 0);
 133         WaitMS(30);
 134         I2C_SetResetStatus(1, 0, 0);
 135         WaitMS(30);
 136         I2C_SetResetStatus(1, 1, 1);
 137         WaitMS(10);
 138 }
 139
 140 // Wait for the clock to go High.
 141 static bool WaitSCL_H_delay(uint32_t delay) {
 142         while (delay--) {
 143                 if (SCL_read) {
 144                         return true;
 145                 }
 146                 I2C_DELAY_1CLK;
 147         }
 148         return false;
 149 }
 150
 151 // 15000 * 3.07us = 46050us. 46.05ms
 152 static bool WaitSCL_H(void) {
 153         return WaitSCL_H_delay(15000);
 154 }
 155
 156 bool WaitSCL_L_delay(uint32_t delay) {
 157         while (delay--) {
 158                 if (!SCL_read) {
 159                         return true;
 160                 }
 161                 I2C_DELAY_1CLK;
 162         }
 163         return false;
 164 }
 165
 166 bool WaitSCL_L(void) {
 167         return WaitSCL_L_delay(15000);
 168 }
 169
 170 static bool I2C_Start(void) {
 171
 172         I2C_DELAY_XCLK(4);
 173         SDA_H; I2C_DELAY_1CLK;
 174         SCL_H;
 175         if (!WaitSCL_H()) return false;
 176
 177         I2C_DELAY_2CLK;
 178
 179         if (!SCL_read) return false;
 180         if (!SDA_read) return false;
 181
 182         SDA_L; I2C_DELAY_2CLK;
 183         return true;
 184 }
 185
 186 // send i2c STOP
 187 static void I2C_Stop(void) {
 188         SCL_L; I2C_DELAY_2CLK;
 189         SDA_L; I2C_DELAY_2CLK;
 190         SCL_H; I2C_DELAY_2CLK;
 191         if (!WaitSCL_H()) return;
 192         SDA_H;
 193         I2C_DELAY_XCLK(8);
 194 }
 195
 196 static bool I2C_WaitAck(void) {
 197         SCL_L; I2C_DELAY_1CLK;
 198         SDA_H; I2C_DELAY_1CLK;
 199         SCL_H;
 200         if (!WaitSCL_H())
 201                 return false;
 202
 203         I2C_DELAY_2CLK;
 204         I2C_DELAY_2CLK;
 205         if (SDA_read) {
 206                 SCL_L;
 207                 return false;
 208         }
 209         SCL_L;
 210         return true;
 211 }
 212
 213 static void I2C_SendByte(uint8_t data) {
 214         uint8_t bits = 8;
 215
 216         while (bits--) {
 217                 SCL_L;
 218                 I2C_DELAY_1CLK;
 219
 220                 if (data & 0x80)
 221                         SDA_H;
 222                 else
 223                         SDA_L;
 224
 225                 data <<= 1;
 226
 227                 I2C_DELAY_1CLK;
 228
 229                 SCL_H;
 230                 if (!WaitSCL_H())
 231                         return;
 232
 233                 I2C_DELAY_2CLK;
 234         }
 235         SCL_L;
 236 }
 237
 238 bool I2C_is_available(void) {
 239         I2C_Reset_EnterMainProgram();
 240         if (!I2C_Start())  // some other device is active on the bus
 241                 return true;
 242         I2C_SendByte(I2C_DEVICE_ADDRESS_MAIN & 0xFE);
 243         if (!I2C_WaitAck()) {  // no response from smartcard reader
 244                 I2C_Stop();
 245                 return false;
 246         }
 247         I2C_Stop();
 248         return true;
 249 }
 250
 251 #ifdef WITH_SMARTCARD
 252 // Reset the SIM_Adapter, then enter the bootloader program
 253 // Reserve£ºFor firmware update.
 254 static void I2C_Reset_EnterBootloader(void) {
 255         I2C_SetResetStatus(0, 1, 1);
 256         WaitMS(100);
 257         I2C_SetResetStatus(1, 1, 1);
 258         WaitMS(10);
 259 }
 260
 261 // Wait max 1800ms or until SCL goes LOW.
 262 // It timeout reading response from card
 263 // Which ever comes first
 264 bool WaitSCL_L_timeout(void){
 265         volatile uint16_t delay = 1800;
 266         while ( delay-- ) {
 267                 // exit on SCL LOW
 268                 if (!SCL_read)
 269                         return true;
 270
 271                 WaitMS(1);
 272         }
 273         return (delay == 0);
 274 }
 275
 276 static bool I2C_WaitForSim() {
 277         // wait for data from card
 278         if (!WaitSCL_L_timeout())
 279                 return false;
 280
 281         // 8051 speaks with smart card.
 282         // 1000*50*3.07 = 153.5ms
 283         // 1byte transfer == 1ms with max frame being 256bytes
 284         if (!WaitSCL_H_delay(10 * 1000 * 50))
 285                 return false;
 286
 287         return true;
 288 }
 289
 290 // Send i2c ACK
 291 static void I2C_Ack(void) {
 292         SCL_L; I2C_DELAY_2CLK;
 293         SDA_L; I2C_DELAY_2CLK;
 294         SCL_H; I2C_DELAY_2CLK;
 295         if (!WaitSCL_H()) return;
 296         SCL_L; I2C_DELAY_2CLK;
 297 }
 298
 299 // Send i2c NACK
 300 static void I2C_NoAck(void) {
 301         SCL_L; I2C_DELAY_2CLK;
 302         SDA_H; I2C_DELAY_2CLK;
 303         SCL_H; I2C_DELAY_2CLK;
 304         if (!WaitSCL_H()) return;
 305         SCL_L; I2C_DELAY_2CLK;
 306 }
 307
 308 static int16_t I2C_ReadByte(void) {
 309         uint8_t bits = 8, b = 0;
 310
 311         SDA_H;
 312         while (bits--) {
 313                 b <<= 1;
 314                 SCL_L;
 315                 if (!WaitSCL_L()) return -2;
 316
 317                 I2C_DELAY_1CLK;
 318
 319                 SCL_H;
 320                 if (!WaitSCL_H()) return -1;
 321
 322                 I2C_DELAY_1CLK;
 323                 if (SDA_read)
 324                         b |= 0x01;
 325         }
 326         SCL_L;
 327         return b;
 328 }
 329
 330 // Sends one byte  ( command to be written, SlaveDevice address)
 331 static bool I2C_WriteCmd(uint8_t device_cmd, uint8_t device_address) {
 332         bool bBreak = true;
 333         do {
 334                 if (!I2C_Start())
 335                         return false;
 336
 337                 I2C_SendByte(device_address & 0xFE);
 338                 if (!I2C_WaitAck())
 339                         break;
 340
 341                 I2C_SendByte(device_cmd);
 342                 if (!I2C_WaitAck())
 343                         break;
 344
 345                 bBreak = false;
 346         } while (false);
 347
 348         I2C_Stop();
 349         if (bBreak) {
 350                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 351                 return false;
 352         }
 353         return true;
 354 }
 355
 356 // Sends 1 byte data (Data to be written, command to be written , SlaveDevice address  ).
 357 static bool I2C_WriteByte(uint8_t data, uint8_t device_cmd, uint8_t device_address) {
 358         bool bBreak = true;
 359         do {
 360                 if (!I2C_Start())
 361                         return false;
 362
 363                 I2C_SendByte(device_address & 0xFE);
 364                 if (!I2C_WaitAck())
 365                         break;
 366
 367                 I2C_SendByte(device_cmd);
 368                 if (!I2C_WaitAck())
 369                         break;
 370
 371                 I2C_SendByte(data);
 372                 if (!I2C_WaitAck())
 373                         break;
 374
 375                 bBreak = false;
 376         } while (false);
 377
 378         I2C_Stop();
 379         if (bBreak) {
 380                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 381                 return false;
 382         }
 383         return true;
 384 }
 385
 386 //Sends a string of data (Array, length, command to be written , SlaveDevice address  ).
 387 // len = uint8 (max buffer to write 256bytes)
 388 static bool I2C_BufferWrite(uint8_t *data, uint8_t len, uint8_t device_cmd, uint8_t device_address) {
 389         bool bBreak = true;
 390         do {
 391                 if (!I2C_Start())
 392                         return false;
 393
 394                 I2C_SendByte(device_address & 0xFE);
 395                 if (!I2C_WaitAck())
 396                         break;
 397
 398                 I2C_SendByte(device_cmd);
 399                 if (!I2C_WaitAck())
 400                         break;
 401
 402                 while (len) {
 403
 404                         I2C_SendByte(*data);
 405                         if (!I2C_WaitAck())
 406                                 break;
 407
 408                         len--;
 409                         data++;
 410                 }
 411
 412                 if (len == 0)
 413                         bBreak = false;
 414         } while (false);
 415
 416         I2C_Stop();
 417         if (bBreak) {
 418                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 419                 return false;
 420         }
 421         return true;
 422 }
 423
 424 // read 1 strings of data (Data array, Readout length, command to be written , SlaveDevice address  ).
 425 // len = uint8 (max buffer to read 256bytes)
 426 static int16_t I2C_BufferRead(uint8_t *data, uint8_t len, uint8_t device_cmd, uint8_t device_address) {
 427
 428         if ( !data || len == 0 )
 429                 return 0;
 430
 431         // extra wait  500us (514us measured)
 432         // 200us  (xx measured)
 433         WaitUS(600);
 434         bool bBreak = true;
 435         uint16_t readcount = 0;
 436
 437         do {
 438                 if (!I2C_Start())
 439                         return 0;
 440
 441                 // 0xB0 / 0xC0  == i2c write
 442                 I2C_SendByte(device_address & 0xFE);
 443                 if (!I2C_WaitAck())
 444                         break;
 445
 446                 I2C_SendByte(device_cmd);
 447                 if (!I2C_WaitAck())
 448                         break;
 449
 450                 // 0xB1 / 0xC1 == i2c read
 451                 I2C_Start();
 452                 I2C_SendByte(device_address | 1);
 453                 if (!I2C_WaitAck())
 454                         break;
 455
 456                 bBreak = false;
 457         } while (false);
 458
 459         if (bBreak) {
 460                 I2C_Stop();
 461                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 462                 return 0;
 463         }
 464
 465         while (len) {
 466
 467                 int16_t tmp = I2C_ReadByte();
 468                 if ( tmp < 0 )
 469                         return tmp;
 470
 471                 *data = (uint8_t)tmp & 0xFF;
 472
 473                 len--;
 474
 475                 // ¶ÁÈ¡µÄµÚÒ»¸ö×Ö½ÚÎªºóÐø³¤¶È
 476                 // The first byte in response is the message length
 477                 if (!readcount && (len > *data)) {
 478                         len = *data;
 479                 } else {
 480                         data++;
 481                 }
 482                 readcount++;
 483
 484                 // acknowledgements. After last byte send NACK.
 485                 if (len == 0)
 486                         I2C_NoAck();
 487                 else
 488                         I2C_Ack();
 489         }
 490
 491         I2C_Stop();
 492
 493         // return bytecount - first byte (which is length byte)
 494         return --readcount;
 495 }
 496
 497 static int16_t I2C_ReadFW(uint8_t *data, uint8_t len, uint8_t msb, uint8_t lsb, uint8_t device_address) {
 498         //START, 0xB0, 0x00, 0x00, START, 0xB1, xx, yy, zz, ......, STOP
 499         bool bBreak = true;
 500         uint8_t readcount = 0;
 501
 502         // sending
 503         do {
 504                 if (!I2C_Start())
 505                         return 0;
 506
 507                 // 0xB0 / 0xC0  i2c write
 508                 I2C_SendByte(device_address & 0xFE);
 509                 if (!I2C_WaitAck())
 510                         break;
 511
 512                 I2C_SendByte(msb);
 513                 if (!I2C_WaitAck())
 514                         break;
 515
 516                 I2C_SendByte(lsb);
 517                 if (!I2C_WaitAck())
 518                         break;
 519
 520                 // 0xB1 / 0xC1  i2c read
 521                 I2C_Start();
 522                 I2C_SendByte(device_address | 1);
 523                 if (!I2C_WaitAck())
 524                         break;
 525
 526                 bBreak = false;
 527         } while (false);
 528
 529         if (bBreak) {
 530                 I2C_Stop();
 531                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 532                 return 0;
 533         }
 534
 535         // reading
 536         while (len) {
 537
 538                 int16_t tmp = I2C_ReadByte();
 539                 if ( tmp < 0 )
 540                         return tmp;
 541
 542                 *data = (uint8_t)tmp & 0xFF;
 543
 544                 data++;
 545                 readcount++;
 546                 len--;
 547
 548                 // acknowledgements. After last byte send NACK.
 549                 if (len == 0)
 550                         I2C_NoAck();
 551                 else
 552                         I2C_Ack();
 553         }
 554
 555         I2C_Stop();
 556         return readcount;
 557 }
 558
 559 static bool I2C_WriteFW(uint8_t *data, uint8_t len, uint8_t msb, uint8_t lsb, uint8_t device_address) {
 560         //START, 0xB0, 0x00, 0x00, xx, yy, zz, ......, STOP
 561         bool bBreak = true;
 562
 563         do {
 564                 if (!I2C_Start())
 565                         return false;
 566
 567                 // 0xB0  == i2c write
 568                 I2C_SendByte(device_address & 0xFE);
 569                 if (!I2C_WaitAck())
 570                         break;
 571
 572                 I2C_SendByte(msb);
 573                 if (!I2C_WaitAck())
 574                         break;
 575
 576                 I2C_SendByte(lsb);
 577                 if (!I2C_WaitAck())
 578                         break;
 579
 580                 while (len) {
 581                         I2C_SendByte(*data);
 582                         if (!I2C_WaitAck())
 583                                 break;
 584
 585                         len--;
 586                         data++;
 587                 }
 588
 589                 if (len == 0)
 590                         bBreak = false;
 591         } while (false);
 592
 593         I2C_Stop();
 594         if (bBreak) {
 595                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 596                 return false;
 597         }
 598         return true;
 599 }
 600
 601 void I2C_print_status(void) {
 602         DbpString("Smart card module (ISO 7816)");
 603         uint8_t resp[] = {0,0,0,0};
 604         I2C_Reset_EnterMainProgram();
 605         uint8_t len = I2C_BufferRead(resp, sizeof(resp), I2C_DEVICE_CMD_GETVERSION, I2C_DEVICE_ADDRESS_MAIN);
 606         if ( len > 0 )
 607                 Dbprintf("  version.................v%x.%02x", resp[0], resp[1]);
 608         else
 609                 DbpString("  version.................FAILED");
 610 }
 611
 612 // Will read response from smart card module,  retries 3 times to get the data.
 613 static bool sc_rx_bytes(uint8_t* dest, uint8_t *destlen) {
 614         uint8_t i = 3;
 615         int16_t len = 0;
 616         while (i--) {
 617
 618                 I2C_WaitForSim();
 619
 620                 len = I2C_BufferRead(dest, *destlen, I2C_DEVICE_CMD_READ, I2C_DEVICE_ADDRESS_MAIN);
 621
 622                 if ( len > 1 ){
 623                         break;
 624                 } else if ( len == 1 ) {
 625                         continue;
 626                 } else if ( len <= 0 ) {
 627                         return false;
 628                 }
 629         }
 630         // after three
 631         if ( len <= 1 )
 632                 return false;
 633
 634         *destlen = (uint8_t)len & 0xFF;
 635         return true;
 636 }
 637
 638 static bool GetATR(smart_card_atr_t *card_ptr) {
 639
 640         if ( !card_ptr ) {
 641                 return false;
 642         }
 643
 644         card_ptr->atr_len = 0;
 645         memset(card_ptr->atr, 0, sizeof(card_ptr->atr));
 646
 647         // Send ATR
 648         // start [C0 01] stop start C1 len aa bb cc stop]
 649         I2C_WriteCmd(I2C_DEVICE_CMD_GENERATE_ATR, I2C_DEVICE_ADDRESS_MAIN);
 650
 651         // wait for sim card to answer.
 652         // 1byte = 1ms, max frame 256bytes. Should wait 256ms at least just in case.
 653         if (!I2C_WaitForSim())
 654                 return false;
 655
 656         // read bytes from module
 657         uint8_t len = sizeof(card_ptr->atr);
 658         if ( !sc_rx_bytes(card_ptr->atr, &len) )
 659                 return false;
 660
 661         card_ptr->atr_len = len;
 662         LogTrace(card_ptr->atr, card_ptr->atr_len, 0, 0, NULL, false);
 663
 664         return true;
 665 }
 666
 667 void SmartCardAtr(void) {
 668         smart_card_atr_t card;
 669         LED_D_ON();
 670         clear_trace();
 671         set_tracing(true);
 672         I2C_Reset_EnterMainProgram();
 673         bool isOK = GetATR( &card );
 674         cmd_send(CMD_ACK, isOK, sizeof(smart_card_atr_t), 0, &card, sizeof(smart_card_atr_t));
 675         set_tracing(false);
 676         LEDsoff();
 677 }
 678
 679 void SmartCardRaw( uint64_t arg0, uint64_t arg1, uint8_t *data ) {
 680
 681         LED_D_ON();
 682
 683         uint8_t len = 0;
 684         uint8_t *resp = BigBuf_malloc(ISO7618_MAX_FRAME);
 685         smartcard_command_t flags = arg0;
 686
 687         if ((flags & SC_CONNECT))
 688                 clear_trace();
 689
 690         set_tracing(true);
 691
 692         if ((flags & SC_CONNECT)) {
 693
 694                 I2C_Reset_EnterMainProgram();
 695
 696                 if ((flags & SC_SELECT)) {
 697                         smart_card_atr_t card;
 698                         bool gotATR = GetATR( &card );
 699                         //cmd_send(CMD_ACK, gotATR, sizeof(smart_card_atr_t), 0, &card, sizeof(smart_card_atr_t));
 700                         if ( !gotATR )
 701                                 goto OUT;
 702                 }
 703         }
 704
 705         if ((flags & SC_RAW) || (flags & SC_RAW_T0)) {
 706
 707                 LogTrace(data, arg1, 0, 0, NULL, true);
 708
 709                 // Send raw bytes
 710                 // asBytes = A0 A4 00 00 02
 711                 // arg1 = len 5
 712                 bool res = I2C_BufferWrite(data, arg1, ((flags & SC_RAW_T0) ? I2C_DEVICE_CMD_SEND_T0 : I2C_DEVICE_CMD_SEND), I2C_DEVICE_ADDRESS_MAIN);
 713                 if ( !res && MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);
 714
 715                 // read bytes from module
 716                 len = ISO7618_MAX_FRAME;
 717                 res = sc_rx_bytes(resp, &len);
 718                 if ( res ) {
 719                         LogTrace(resp, len, 0, 0, NULL, false);
 720                 } else {
 721                         len = 0;
 722                 }
 723         }
 724 OUT:
 725         cmd_send(CMD_ACK, len, 0, 0, resp, len);
 726         BigBuf_free();
 727         set_tracing(false);
 728         LEDsoff();
 729 }
 730
 731 void SmartCardUpgrade(uint64_t arg0) {
 732
 733         LED_C_ON();
 734
 735         #define I2C_BLOCK_SIZE 128
 736         // write.   Sector0,  with 11,22,33,44
 737         // erase is 128bytes, and takes 50ms to execute
 738
 739         I2C_Reset_EnterBootloader();
 740
 741         bool isOK = true;
 742         int16_t res = 0;
 743         uint16_t length = arg0;
 744         uint16_t pos = 0;
 745         uint8_t *fwdata = BigBuf_get_addr();
 746         uint8_t *verfiydata = BigBuf_malloc(I2C_BLOCK_SIZE);
 747
 748         while (length) {
 749
 750                 uint8_t msb = (pos >> 8) & 0xFF;
 751                 uint8_t lsb = pos & 0xFF;
 752
 753                 Dbprintf("FW %02X%02X", msb, lsb);
 754
 755                 size_t size = MIN(I2C_BLOCK_SIZE, length);
 756
 757                 // write
 758                 res = I2C_WriteFW(fwdata+pos, size, msb, lsb, I2C_DEVICE_ADDRESS_BOOT);
 759                 if ( !res ) {
 760                         DbpString("Writing failed");
 761                         isOK = false;
 762                         break;
 763                 }
 764
 765                 // writing takes time.
 766                 WaitMS(50);
 767
 768                 // read
 769                 res = I2C_ReadFW(verfiydata, size, msb, lsb, I2C_DEVICE_ADDRESS_BOOT);
 770                 if ( res <= 0) {
 771                         DbpString("Reading back failed");
 772                         isOK = false;
 773                         break;
 774                 }
 775
 776                 // cmp
 777                 if ( 0 != memcmp(fwdata+pos, verfiydata, size)) {
 778                         DbpString("not equal data");
 779                         isOK = false;
 780                         break;
 781                 }
 782
 783                 length -= size;
 784                 pos += size;
 785         }
 786         cmd_send(CMD_ACK, isOK, pos, 0, 0, 0);
 787         LED_C_OFF();
 788         BigBuf_free();
 789 }
 790
 791 // unfinished (or not needed?)
 792 //void SmartCardSetBaud(uint64_t arg0) {
 793 //}
 794
 795 void SmartCardSetClock(uint64_t arg0) {
 796         LED_D_ON();
 797         set_tracing(true);
 798         I2C_Reset_EnterMainProgram();
 799
 800         // Send SIM CLC
 801         // start [C0 05 xx] stop
 802         I2C_WriteByte(arg0, I2C_DEVICE_CMD_SIM_CLC, I2C_DEVICE_ADDRESS_MAIN);
 803
 804         cmd_send(CMD_ACK, 1, 0, 0, 0, 0);
 805         set_tracing(false);
 806         LEDsoff();
 807 }
 808
 809 #endif