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"

21 #include "usb_cdc.h"

23 #ifdef WITH_SMARTCARD

24 #include "smartcard.h"

25 #endif

28 #define GPIO_RST AT91C_PIO_PA1

29 #define GPIO_SCL AT91C_PIO_PA5

30 #define GPIO_SDA AT91C_PIO_PA7

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)

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

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

40 #define I2C_ERROR "I2C_WaitAck Error"

42 static volatile unsigned long c;

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

45 // timer.

46 // I2CSpinDelayClk(4) = 12.31us

47 // I2CSpinDelayClk(1) = 3.07us

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

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

50 }

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

57 #define ISO7618_MAX_FRAME 255

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

 static void I2C_recovery(void) {

62 DbpString("Performing i2c bus recovery");

64 // reset I2C

65 SDA_H; SCL_H;

67 //9nth cycle acts as NACK

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

                 SCL_H; WaitUS(5);

                 SCL_L; WaitUS(5);

71 }

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

         SDA_L; WaitUS(5);

         SCL_H; WaitUS(2);

         SDA_H; WaitUS(2);

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 }

 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)

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

96 // set all three outputs to high

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

99 // 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);

102

103 bool isok = (SCL_read && SDA_read);

104 if ( !isok )

105 I2C_recovery();

106

107 }

108

109 // set the reset state

 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.

 static void I2C_Reset_EnterMainProgram(void) {

130 StartTicks();

131 I2C_init();

         I2C_SetResetStatus(0, 0, 0);

133 WaitMS(30);

         I2C_SetResetStatus(1, 0, 0);

135 WaitMS(30);

         I2C_SetResetStatus(1, 1, 1);

137 WaitMS(10);

138 }

139

140 // Wait for the clock to go High.

 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

 static bool WaitSCL_H(void) {

         return WaitSCL_H_delay(15000);

154 }

155

 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

 bool WaitSCL_L(void) {

         return WaitSCL_L_delay(15000);

168 }

169

 static bool I2C_Start(void) {

171

172 I2C_DELAY_XCLK(4);

173 SDA_H; I2C_DELAY_1CLK;

174 SCL_H;

         if (!WaitSCL_H()) return false;

176

177 I2C_DELAY_2CLK;

178

         if (!SCL_read) return false;

         if (!SDA_read) return false;

181

182 SDA_L; I2C_DELAY_2CLK;

183 return true;

184 }

185

186 // send i2c STOP

 static void I2C_Stop(void) {

188 SCL_L; I2C_DELAY_2CLK;

189 SDA_L; I2C_DELAY_2CLK;

190 SCL_H; I2C_DELAY_2CLK;

         if (!WaitSCL_H()) return;

192 SDA_H;

193 I2C_DELAY_XCLK(8);

194 }

195

 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

 static void I2C_SendByte(uint8_t data) {

214 uint8_t bits = 8;

215

216 while (bits--) {

217 SCL_L;

218 I2C_DELAY_1CLK;

219

                 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

 bool I2C_is_available(void) {

239 I2C_Reset_EnterMainProgram();

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

241 return true;

         I2C_SendByte(I2C_DEVICE_ADDRESS_MAIN & 0xFE);

         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.

 static void I2C_Reset_EnterBootloader(void) {

         I2C_SetResetStatus(0, 1, 1);

256 WaitMS(100);

         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

 bool WaitSCL_L_timeout(void){

         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 }

         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

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

285 return false;

286

287 return true;

288 }

289

290 // Send i2c ACK

 static void I2C_Ack(void) {

292 SCL_L; I2C_DELAY_2CLK;

293 SDA_L; I2C_DELAY_2CLK;

294 SCL_H; I2C_DELAY_2CLK;

         if (!WaitSCL_H()) return;

296 SCL_L; I2C_DELAY_2CLK;

297 }

298

299 // Send i2c NACK

 static void I2C_NoAck(void) {

301 SCL_L; I2C_DELAY_2CLK;

302 SDA_H; I2C_DELAY_2CLK;

303 SCL_H; I2C_DELAY_2CLK;

         if (!WaitSCL_H()) return;

305 SCL_L; I2C_DELAY_2CLK;

306 }

307

 static int16_t I2C_ReadByte(void) {

         uint8_t bits = 8, b = 0;

310

311 SDA_H;

312 while (bits--) {

313 b <<= 1;

314 SCL_L;

                 if (!WaitSCL_L()) return -2;

316

317 I2C_DELAY_1CLK;

318

319 SCL_H;

                 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)

 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

                 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;

         } while (false);

347

348 I2C_Stop();

349 if (bBreak) {

                 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 ).

 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

                 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;

         } while (false);

377

378 I2C_Stop();

379 if (bBreak) {

                 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)

 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

                 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

                 if (len == 0)

413 bBreak = false;

         } while (false);

415

416 I2C_Stop();

417 if (bBreak) {

                 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)

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

427

         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

                 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();

                 I2C_SendByte(device_address | 1);

453 if (!I2C_WaitAck())

454 break;

455

456 bBreak = false;

         } while (false);

458

459 if (bBreak) {

460 I2C_Stop();

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

462 return 0;

463 }

464

465 while (len) {

466

467 int16_t tmp = I2C_ReadByte();

                 if ( tmp < 0 )

469 return tmp;

470

                 *data = (uint8_t)tmp & 0xFF;

472

473 len--;

474

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

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

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

478 len = *data;

479 } else {

480 data++;

481 }

482 readcount++;

483

484 // acknowledgements. After last byte send NACK.

                 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

 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

                 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();

                 I2C_SendByte(device_address | 1);

523 if (!I2C_WaitAck())

524 break;

525

526 bBreak = false;

         } while (false);

528

529 if (bBreak) {

530 I2C_Stop();

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

532 return 0;

533 }

534

535 // reading

536 while (len) {

537

538 int16_t tmp = I2C_ReadByte();

                 if ( tmp < 0 )

540 return tmp;

541

                 *data = (uint8_t)tmp & 0xFF;

543

544 data++;

545 readcount++;

546 len--;

547

548 // acknowledgements. After last byte send NACK.

                 if (len == 0)

550 I2C_NoAck();

551 else

552 I2C_Ack();

553 }

554

555 I2C_Stop();

556 return readcount;

557 }

558

 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

                 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

                 if (len == 0)

590 bBreak = false;

         } while (false);

592

593 I2C_Stop();

594 if (bBreak) {

                 if ( MF_DBGLEVEL > 3 ) DbpString(I2C_ERROR);

596 return false;

597 }

598 return true;

599 }

600

 void I2C_print_status(void) {

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

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

604 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]);

608 else

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

610 }

611

612 // 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) {

614 uint8_t i = 3;

615 int16_t len = 0;

616 while (i--) {

617

618 I2C_WaitForSim();

619

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

621

                 if ( len > 1 ){

623 break;

                 } else if ( len == 1 ) {

625 continue;

                 } else if ( len <= 0 ) {

627 return false;

628 }

629 }

630 // after three

         if ( len <= 1 )

632 return false;

633

         *destlen = (uint8_t)len & 0xFF;

635 return true;

636 }

637

 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;

         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

         uint8_t len = sizeof(card_ptr->atr);

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

659 return false;

660

661 card_ptr->atr_len = len;

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

663

664 return true;

665 }

666

 void SmartCardAtr(void) {

668 smart_card_atr_t card;

669 LED_D_ON();

670 clear_trace();

671 set_tracing(true);

672 I2C_Reset_EnterMainProgram();

         bool isOK = GetATR( &card );

         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

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

680

681 LED_D_ON();

682

683 uint8_t len = 0;

         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;

                         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

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

706

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

708

709 // Send raw bytes

710 // asBytes = A0 A4 00 00 02

711 // 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);

714

715 // read bytes from module

716 len = ISO7618_MAX_FRAME;

                 res = sc_rx_bytes(resp, &len);

718 if ( res ) {

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

720 } else {

721 len = 0;

722 }

723 }

724 OUT:

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

726 BigBuf_free();

727 set_tracing(false);

728 LEDsoff();

729 }

730

 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;

         uint8_t *fwdata = BigBuf_get_addr();

         uint8_t *verfiydata = BigBuf_malloc(I2C_BLOCK_SIZE);

747

748 while (length) {

749

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

                 uint8_t lsb = pos & 0xFF;

752

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

754

                 size_t size = MIN(I2C_BLOCK_SIZE, length);

756

757 // write

                 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

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

                 if ( res <= 0) {

771 DbpString("Reading back failed");

772 isOK = false;

773 break;

774 }

775

776 // cmp

                 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 }

         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

 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

         I2C_WriteByte(arg0, I2C_DEVICE_CMD_SIM_CLC, I2C_DEVICE_ADDRESS_MAIN);

803

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

805 set_tracing(false);

806 LEDsoff();

807 }

808

809 #endif