git.zerfleddert.de Git - proxmark3-svn/blob

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 //-----------------------------------------------------------------------------

12 #include "i2c.h"

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"

22 #ifdef WITH_SMARTCARD

23 #include "smartcard.h"

24 #endif

27 #define GPIO_RST AT91C_PIO_PA1

28 #define GPIO_SCL AT91C_PIO_PA5

29 #define GPIO_SDA AT91C_PIO_PA7

31 #define SCL_H HIGH(GPIO_SCL)

32 #define SCL_L LOW(GPIO_SCL)

33 #define SDA_H HIGH(GPIO_SDA)

34 #define SDA_L LOW(GPIO_SDA)

36 #define SCL_read (AT91C_BASE_PIOA->PIO_PDSR & GPIO_SCL)

37 #define SDA_read (AT91C_BASE_PIOA->PIO_PDSR & GPIO_SDA)

39 #define I2C_ERROR "I2C_WaitAck Error"

41 static volatile unsigned long c;

43 // Ö±½ÓÊ¹ÓÃÑ»·À´ÑÓÊ±£¬Ò»¸öÑ»· 6 ÌõÖ¸Áî£¬48M£¬ Delay=1 ´ó¸ÅÎª 200kbps

44 // timer.

45 // I2CSpinDelayClk(4) = 12.31us

46 // I2CSpinDelayClk(1) = 3.07us

 static void __attribute__((optimize("O0"))) I2CSpinDelayClk(uint16_t delay) {

         for (c = delay * 2; c; c--) {};

49 }

51 // communication delay functions

52 #define I2C_DELAY_1CLK I2CSpinDelayClk(1)

53 #define I2C_DELAY_2CLK I2CSpinDelayClk(2)

54 #define I2C_DELAY_XCLK(x) I2CSpinDelayClk((x))

56 #define ISO7618_MAX_FRAME 255

58 // try i2c bus recovery at 100kHz = 5uS high, 5uS low

 static void I2C_recovery(void) {

61 DbpString("Performing i2c bus recovery");

63 // reset I2C

64 SDA_H; SCL_H;

66 //9nth cycle acts as NACK

         for (int i = 0; i < 10; i++)  {

                 SCL_H; WaitUS(5);

                 SCL_L; WaitUS(5);

70 }

72 //a STOP signal (SDA from low to high while CLK is high)

         SDA_L; WaitUS(5);

         SCL_H; WaitUS(2);

         SDA_H; WaitUS(2);

77 bool isok = (SCL_read && SDA_read);

78 if (!SDA_read)

79 DbpString("I2C bus recovery error: SDA still LOW");

80 if (!SCL_read)

81 DbpString("I2C bus recovery error: SCL still LOW");

82 if (isok)

83 DbpString("I2C bus recovery complete");

84 }

 static void I2C_init(void) {

87 // Configure reset pin

88 AT91C_BASE_PIOA->PIO_PPUDR = GPIO_RST; // disable pull up resistor

89 AT91C_BASE_PIOA->PIO_MDDR = GPIO_RST; // push-pull output (multidriver disabled)

91 // Configure SCL and SDA pins

         AT91C_BASE_PIOA->PIO_PPUER |= (GPIO_SCL | GPIO_SDA);  // enable pull up resistor

         AT91C_BASE_PIOA->PIO_MDER |= (GPIO_SCL | GPIO_SDA);   // open drain output (multidriver enabled) - requires external pull up resistor

95 // set all three outputs to high

         AT91C_BASE_PIOA->PIO_SODR |= (GPIO_SCL | GPIO_SDA | GPIO_RST);

98 // configure all three pins as output, controlled by PIOA

         AT91C_BASE_PIOA->PIO_OER |= (GPIO_SCL | GPIO_SDA | GPIO_RST);

         AT91C_BASE_PIOA->PIO_PER |= (GPIO_SCL | GPIO_SDA | GPIO_RST);

101

102 bool isok = (SCL_read && SDA_read);

103 if ( !isok )

104 I2C_recovery();

105

106 }

107

108 // set the reset state

 static void I2C_SetResetStatus(uint8_t LineRST, uint8_t LineSCK, uint8_t LineSDA) {

110 if (LineRST)

111 HIGH(GPIO_RST);

112 else

113 LOW(GPIO_RST);

114

115 if (LineSCK)

116 HIGH(GPIO_SCL);

117 else

118 LOW(GPIO_SCL);

119

120 if (LineSDA)

121 HIGH(GPIO_SDA);

122 else

123 LOW(GPIO_SDA);

124 }

125

126 // Reset the SIM_Adapter, then enter the main program

127 // Note: the SIM_Adapter will not enter the main program after power up. Please run this function before use SIM_Adapter.

 static void I2C_Reset_EnterMainProgram(void) {

129 StartTicks();

130 I2C_init();

         I2C_SetResetStatus(0, 0, 0);

132 WaitMS(30);

         I2C_SetResetStatus(1, 0, 0);

134 WaitMS(30);

         I2C_SetResetStatus(1, 1, 1);

136 WaitMS(10);

137 }

138

139 // Wait for the clock to go High.

 static bool WaitSCL_H_delay(uint32_t delay) {

141 while (delay--) {

142 if (SCL_read) {

143 return true;

144 }

145 I2C_DELAY_1CLK;

146 }

147 return false;

148 }

149

150 // 15000 * 3.07us = 46050us. 46.05ms

 static bool WaitSCL_H(void) {

         return WaitSCL_H_delay(15000);

153 }

154

 bool WaitSCL_L_delay(uint32_t delay) {

156 while (delay--) {

157 if (!SCL_read) {

158 return true;

159 }

160 I2C_DELAY_1CLK;

161 }

162 return false;

163 }

164

 bool WaitSCL_L(void) {

         return WaitSCL_L_delay(15000);

167 }

168

 static bool I2C_Start(void) {

170

171 I2C_DELAY_XCLK(4);

172 SDA_H; I2C_DELAY_1CLK;

173 SCL_H;

         if (!WaitSCL_H()) return false;

175

176 I2C_DELAY_2CLK;

177

         if (!SCL_read) return false;

         if (!SDA_read) return false;

180

181 SDA_L; I2C_DELAY_2CLK;

182 return true;

183 }

184

185 // send i2c STOP

 static void I2C_Stop(void) {

187 SCL_L; I2C_DELAY_2CLK;

188 SDA_L; I2C_DELAY_2CLK;

189 SCL_H; I2C_DELAY_2CLK;

         if (!WaitSCL_H()) return;

191 SDA_H;

192 I2C_DELAY_XCLK(8);

193 }

194

 static bool I2C_WaitAck(void) {

196 SCL_L; I2C_DELAY_1CLK;

197 SDA_H; I2C_DELAY_1CLK;

198 SCL_H;

199 if (!WaitSCL_H())

200 return false;

201

202 I2C_DELAY_2CLK;

203 I2C_DELAY_2CLK;

204 if (SDA_read) {

205 SCL_L;

206 return false;

207 }

208 SCL_L;

209 return true;

210 }

211

 static void I2C_SendByte(uint8_t data) {

213 uint8_t bits = 8;

214

215 while (bits--) {

216 SCL_L;

217 I2C_DELAY_1CLK;

218

                 if (data & 0x80)

220 SDA_H;

221 else

222 SDA_L;

223

224 data <<= 1;

225

226 I2C_DELAY_1CLK;

227

228 SCL_H;

229 if (!WaitSCL_H())

230 return;

231

232 I2C_DELAY_2CLK;

233 }

234 SCL_L;

235 }

236

 bool I2C_is_available(void) {

238 I2C_Reset_EnterMainProgram();

         if (!I2C_Start())  // some other device is active on the bus

240 return true;

         I2C_SendByte(I2C_DEVICE_ADDRESS_MAIN & 0xFE);

         if (!I2C_WaitAck()) {  // no response from smartcard reader

243 I2C_Stop();

244 return false;

245 }

246 I2C_Stop();

247 return true;

248 }

249

250 #ifdef WITH_SMARTCARD

251 // Reset the SIM_Adapter, then enter the bootloader program

252 // Reserve£ºFor firmware update.

 static void I2C_Reset_EnterBootloader(void) {

         I2C_SetResetStatus(0, 1, 1);

255 WaitMS(100);

         I2C_SetResetStatus(1, 1, 1);

257 WaitMS(10);

258 }

259

260 // Wait max 1800ms or until SCL goes LOW.

261 // It timeout reading response from card

262 // Which ever comes first

 bool WaitSCL_L_timeout(void){

         volatile uint16_t delay = 1800;

265 while ( delay-- ) {

266 // exit on SCL LOW

267 if (!SCL_read)

268 return true;

269

270 WaitMS(1);

271 }

         return (delay == 0);

273 }

274

275 static bool I2C_WaitForSim() {

276 // wait for data from card

277 if (!WaitSCL_L_timeout())

278 return false;

279

280 // 8051 speaks with smart card.

281 // 1000*50*3.07 = 153.5ms

282 // 1byte transfer == 1ms with max frame being 256bytes

         if (!WaitSCL_H_delay(10 * 1000 * 50))

284 return false;

285

286 return true;

287 }

288

289 // Send i2c ACK

 static void I2C_Ack(void) {

291 SCL_L; I2C_DELAY_2CLK;

292 SDA_L; I2C_DELAY_2CLK;

293 SCL_H; I2C_DELAY_2CLK;

         if (!WaitSCL_H()) return;

295 SCL_L; I2C_DELAY_2CLK;

296 }

297

298 // Send i2c NACK

 static void I2C_NoAck(void) {

300 SCL_L; I2C_DELAY_2CLK;

301 SDA_H; I2C_DELAY_2CLK;

302 SCL_H; I2C_DELAY_2CLK;

         if (!WaitSCL_H()) return;

304 SCL_L; I2C_DELAY_2CLK;

305 }

306

 static int16_t I2C_ReadByte(void) {

         uint8_t bits = 8, b = 0;

309

310 SDA_H;

311 while (bits--) {

312 b <<= 1;

313 SCL_L;

                 if (!WaitSCL_L()) return -2;

315

316 I2C_DELAY_1CLK;

317

318 SCL_H;

                 if (!WaitSCL_H()) return -1;

320

321 I2C_DELAY_1CLK;

322 if (SDA_read)

323 b |= 0x01;

324 }

325 SCL_L;

326 return b;

327 }

328

329 // Sends one byte ( command to be written, SlaveDevice address)

 static bool I2C_WriteCmd(uint8_t device_cmd, uint8_t device_address) {

331 bool bBreak = true;

332 do {

333 if (!I2C_Start())

334 return false;

335

                 I2C_SendByte(device_address & 0xFE);

337 if (!I2C_WaitAck())

338 break;

339

340 I2C_SendByte(device_cmd);

341 if (!I2C_WaitAck())

342 break;

343

344 bBreak = false;

         } while (false);

346

347 I2C_Stop();

348 if (bBreak) {

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

350 return false;

351 }

352 return true;

353 }

354

355 // Sends 1 byte data (Data to be written, command to be written , SlaveDevice address ).

 static bool I2C_WriteByte(uint8_t data, uint8_t device_cmd, uint8_t device_address) {

357 bool bBreak = true;

358 do {

359 if (!I2C_Start())

360 return false;

361

                 I2C_SendByte(device_address & 0xFE);

363 if (!I2C_WaitAck())

364 break;

365

366 I2C_SendByte(device_cmd);

367 if (!I2C_WaitAck())

368 break;

369

370 I2C_SendByte(data);

371 if (!I2C_WaitAck())

372 break;

373

374 bBreak = false;

         } while (false);

376

377 I2C_Stop();

378 if (bBreak) {

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

380 return false;

381 }

382 return true;

383 }

384

385 //Sends a string of data (Array, length, command to be written , SlaveDevice address ).

386 // len = uint8 (max buffer to write 256bytes)

 static bool I2C_BufferWrite(uint8_t *data, uint8_t len, uint8_t device_cmd, uint8_t device_address) {

388 bool bBreak = true;

389 do {

390 if (!I2C_Start())

391 return false;

392

                 I2C_SendByte(device_address & 0xFE);

394 if (!I2C_WaitAck())

395 break;

396

397 I2C_SendByte(device_cmd);

398 if (!I2C_WaitAck())

399 break;

400

401 while (len) {

402

403 I2C_SendByte(*data);

404 if (!I2C_WaitAck())

405 break;

406

407 len--;

408 data++;

409 }

410

                 if (len == 0)

412 bBreak = false;

         } while (false);

414

415 I2C_Stop();

416 if (bBreak) {

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

418 return false;

419 }

420 return true;

421 }

422

423 // read 1 strings of data (Data array, Readout length, command to be written , SlaveDevice address ).

424 // len = uint8 (max buffer to read 256bytes)

 static int16_t I2C_BufferRead(uint8_t *data, uint8_t len, uint8_t device_cmd, uint8_t device_address) {

426

         if ( !data || len == 0 )

428 return 0;

429

430 // extra wait 500us (514us measured)

431 // 200us (xx measured)

432 WaitUS(600);

433 bool bBreak = true;

434 uint16_t readcount = 0;

435

436 do {

437 if (!I2C_Start())

438 return 0;

439

440 // 0xB0 / 0xC0 == i2c write

                 I2C_SendByte(device_address & 0xFE);

442 if (!I2C_WaitAck())

443 break;

444

445 I2C_SendByte(device_cmd);

446 if (!I2C_WaitAck())

447 break;

448

449 // 0xB1 / 0xC1 == i2c read

450 I2C_Start();

                 I2C_SendByte(device_address | 1);

452 if (!I2C_WaitAck())

453 break;

454

455 bBreak = false;

         } while (false);

457

458 if (bBreak) {

459 I2C_Stop();

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

461 return 0;

462 }

463

464 while (len) {

465

466 int16_t tmp = I2C_ReadByte();

                 if ( tmp < 0 )

468 return tmp;

469

                 *data = (uint8_t)tmp & 0xFF;

471

472 len--;

473

474 // ¶ÁÈ¡µÄµÚÒ»¸ö×Ö½ÚÎªºóÐø³¤¶È

475 // The first byte in response is the message length

                 if (!readcount && (len > *data)) {

477 len = *data;

478 } else {

479 data++;

480 }

481 readcount++;

482

483 // acknowledgements. After last byte send NACK.

                 if (len == 0)

485 I2C_NoAck();

486 else

487 I2C_Ack();

488 }

489

490 I2C_Stop();

491

492 // return bytecount - first byte (which is length byte)

493 return --readcount;

494 }

495

 static int16_t I2C_ReadFW(uint8_t *data, uint8_t len, uint8_t msb, uint8_t lsb, uint8_t device_address) {

497 //START, 0xB0, 0x00, 0x00, START, 0xB1, xx, yy, zz, ......, STOP

498 bool bBreak = true;

499 uint8_t readcount = 0;

500

501 // sending

502 do {

503 if (!I2C_Start())

504 return 0;

505

506 // 0xB0 / 0xC0 i2c write

                 I2C_SendByte(device_address & 0xFE);

508 if (!I2C_WaitAck())

509 break;

510

511 I2C_SendByte(msb);

512 if (!I2C_WaitAck())

513 break;

514

515 I2C_SendByte(lsb);

516 if (!I2C_WaitAck())

517 break;

518

519 // 0xB1 / 0xC1 i2c read

520 I2C_Start();

                 I2C_SendByte(device_address | 1);

522 if (!I2C_WaitAck())

523 break;

524

525 bBreak = false;

         } while (false);

527

528 if (bBreak) {

529 I2C_Stop();

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

531 return 0;

532 }

533

534 // reading

535 while (len) {

536

537 int16_t tmp = I2C_ReadByte();

                 if ( tmp < 0 )

539 return tmp;

540

                 *data = (uint8_t)tmp & 0xFF;

542

543 data++;

544 readcount++;

545 len--;

546

547 // acknowledgements. After last byte send NACK.

                 if (len == 0)

549 I2C_NoAck();

550 else

551 I2C_Ack();

552 }

553

554 I2C_Stop();

555 return readcount;

556 }

557

 static bool I2C_WriteFW(uint8_t *data, uint8_t len, uint8_t msb, uint8_t lsb, uint8_t device_address) {

559 //START, 0xB0, 0x00, 0x00, xx, yy, zz, ......, STOP

560 bool bBreak = true;

561

562 do {

563 if (!I2C_Start())

564 return false;

565

566 // 0xB0 == i2c write

                 I2C_SendByte(device_address & 0xFE);

568 if (!I2C_WaitAck())

569 break;

570

571 I2C_SendByte(msb);

572 if (!I2C_WaitAck())

573 break;

574

575 I2C_SendByte(lsb);

576 if (!I2C_WaitAck())

577 break;

578

579 while (len) {

580 I2C_SendByte(*data);

581 if (!I2C_WaitAck())

582 break;

583

584 len--;

585 data++;

586 }

587

                 if (len == 0)

589 bBreak = false;

         } while (false);

591

592 I2C_Stop();

593 if (bBreak) {

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

595 return false;

596 }

597 return true;

598 }

599

 void I2C_print_status(void) {

601 DbpString("Smart card module (ISO 7816)");

         uint8_t resp[] = {0,0,0,0};

603 I2C_Reset_EnterMainProgram();

         uint8_t len = I2C_BufferRead(resp, sizeof(resp), I2C_DEVICE_CMD_GETVERSION, I2C_DEVICE_ADDRESS_MAIN);

         if ( len > 0 )

                 Dbprintf("  version.................v%x.%02x", resp[0], resp[1]);

607 else

608 DbpString(" version.................FAILED");

609 }

610

611 // Will read response from smart card module, retries 3 times to get the data.

 static bool sc_rx_bytes(uint8_t* dest, uint8_t *destlen) {

613 uint8_t i = 3;

614 int16_t len = 0;

615 while (i--) {

616

617 I2C_WaitForSim();

618

                 len = I2C_BufferRead(dest, *destlen, I2C_DEVICE_CMD_READ, I2C_DEVICE_ADDRESS_MAIN);

620

                 if ( len > 1 ){

622 break;

                 } else if ( len == 1 ) {

624 continue;

                 } else if ( len <= 0 ) {

626 return false;

627 }

628 }

629 // after three

         if ( len <= 1 )

631 return false;

632

         *destlen = (uint8_t)len & 0xFF;

634 return true;

635 }

636

 static bool GetATR(smart_card_atr_t *card_ptr) {

638

639 if ( !card_ptr ) {

640 return false;

641 }

642

643 card_ptr->atr_len = 0;

         memset(card_ptr->atr, 0, sizeof(card_ptr->atr));

645

646 // Send ATR

647 // start [C0 01] stop start C1 len aa bb cc stop]

648 I2C_WriteCmd(I2C_DEVICE_CMD_GENERATE_ATR, I2C_DEVICE_ADDRESS_MAIN);

649

650 // wait for sim card to answer.

651 // 1byte = 1ms, max frame 256bytes. Should wait 256ms at least just in case.

652 if (!I2C_WaitForSim())

653 return false;

654

655 // read bytes from module

         uint8_t len = sizeof(card_ptr->atr);

         if ( !sc_rx_bytes(card_ptr->atr, &len) )                

658 return false;

659

660 card_ptr->atr_len = len;

         LogTrace(card_ptr->atr, card_ptr->atr_len, 0, 0, NULL, false);

662

663 return true;

664 }

665

 void SmartCardAtr(void) {

667 smart_card_atr_t card;

668 LED_D_ON();

669 clear_trace();

670 set_tracing(true);

671 I2C_Reset_EnterMainProgram();

         bool isOK = GetATR( &card );

         cmd_send(CMD_ACK, isOK, sizeof(smart_card_atr_t), 0, &card, sizeof(smart_card_atr_t));

674 set_tracing(false);

675 LEDsoff();

676 }

677

 void SmartCardRaw( uint64_t arg0, uint64_t arg1, uint8_t *data ) {

679

680 LED_D_ON();

681

682 uint8_t len = 0;

         uint8_t *resp = BigBuf_malloc(ISO7618_MAX_FRAME);

684 smartcard_command_t flags = arg0;

685

686 if ((flags & SC_CONNECT))

687 clear_trace();

688

689 set_tracing(true);

690

691 if ((flags & SC_CONNECT)) {

692

693 I2C_Reset_EnterMainProgram();

694

695 if ((flags & SC_SELECT)) {

696 smart_card_atr_t card;

                         bool gotATR = GetATR( &card );

698 //cmd_send(CMD_ACK, gotATR, sizeof(smart_card_atr_t), 0, &card, sizeof(smart_card_atr_t));

699 if ( !gotATR )

700 goto OUT;

701 }

702 }

703

         if ((flags & SC_RAW) || (flags & SC_RAW_T0)) {

705

                 LogTrace(data, arg1, 0, 0, NULL, true);

707

708 // Send raw bytes

709 // asBytes = A0 A4 00 00 02

710 // arg1 = len 5

                 bool res = I2C_BufferWrite(data, arg1, ((flags & SC_RAW_T0) ? I2C_DEVICE_CMD_SEND_T0 : I2C_DEVICE_CMD_SEND), I2C_DEVICE_ADDRESS_MAIN);

                 if ( !res && MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

713

714 // read bytes from module

715 len = ISO7618_MAX_FRAME;

                 res = sc_rx_bytes(resp, &len);

717 if ( res ) {

                         LogTrace(resp, len, 0, 0, NULL, false);

719 } else {

720 len = 0;

721 }

722 }

723 OUT:

         cmd_send(CMD_ACK, len, 0, 0, resp, len);

725 BigBuf_free();

726 set_tracing(false);

727 LEDsoff();

728 }

729

 void SmartCardUpgrade(uint64_t arg0) {

731

732 LED_C_ON();

733

734 #define I2C_BLOCK_SIZE 128

735 // write. Sector0, with 11,22,33,44

736 // erase is 128bytes, and takes 50ms to execute

737

738 I2C_Reset_EnterBootloader();

739

740 bool isOK = true;

741 int16_t res = 0;

742 uint16_t length = arg0;

743 uint16_t pos = 0;

         uint8_t *fwdata = BigBuf_get_addr();

         uint8_t *verfiydata = BigBuf_malloc(I2C_BLOCK_SIZE);

746

747 while (length) {

748

                 uint8_t msb = (pos >> 8) & 0xFF;

                 uint8_t lsb = pos & 0xFF;

751

                 Dbprintf("FW %02X%02X", msb, lsb);

753

                 size_t size = MIN(I2C_BLOCK_SIZE, length);

755

756 // write

                 res = I2C_WriteFW(fwdata+pos, size, msb, lsb, I2C_DEVICE_ADDRESS_BOOT);

758 if ( !res ) {

759 DbpString("Writing failed");

760 isOK = false;

761 break;

762 }

763

764 // writing takes time.

765 WaitMS(50);

766

767 // read

                 res = I2C_ReadFW(verfiydata, size, msb, lsb, I2C_DEVICE_ADDRESS_BOOT);

                 if ( res <= 0) {

770 DbpString("Reading back failed");

771 isOK = false;

772 break;

773 }

774

775 // cmp

                 if ( 0 != memcmp(fwdata+pos, verfiydata, size)) {

777 DbpString("not equal data");

778 isOK = false;

779 break;

780 }

781

782 length -= size;

783 pos += size;

784 }

         cmd_send(CMD_ACK, isOK, pos, 0, 0, 0);

786 LED_C_OFF();

787 BigBuf_free();

788 }

789

790 // unfinished (or not needed?)

791 //void SmartCardSetBaud(uint64_t arg0) {

792 //}

793

 void SmartCardSetClock(uint64_t arg0) {

795 LED_D_ON();

796 set_tracing(true);

797 I2C_Reset_EnterMainProgram();

798

799 // Send SIM CLC

800 // start [C0 05 xx] stop

         I2C_WriteByte(arg0, I2C_DEVICE_CMD_SIM_CLC, I2C_DEVICE_ADDRESS_MAIN);

802

         cmd_send(CMD_ACK, 1, 0, 0, 0, 0);

804 set_tracing(false);

805 LEDsoff();

806 }

807

808 #endif