fixed bug in ASKbiphaseDemod()

[proxmark3-svn] / armsrc / iso14443a.c

diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index 0a9f7c039333764b9f9cbe27d2ee1ddba9b4bba3..2f4baf175d5a413c16252a3f58a0115b7461f853 100644 (file)
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -25,6 +25,7 @@
 #include "BigBuf.h"
 #include "protocols.h"
 #include "parity.h"
 #include "BigBuf.h"
 #include "protocols.h"
 #include "parity.h"

+#include "fpgaloader.h"

 
 typedef struct {
        enum {
 
 typedef struct {
        enum {


@@ -189,13 +190,14 @@ void iso14a_set_trigger(bool enable) {
 
 
 void iso14a_set_timeout(uint32_t timeout) {
 
 
 void iso14a_set_timeout(uint32_t timeout) {

-       iso14a_timeout = timeout - (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/(16*8) + 2;
+       // adjust timeout by FPGA delays and 2 additional ssp_frames to detect SOF
+       iso14a_timeout = timeout + (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/(16*8) + 2;

        if(MF_DBGLEVEL >= 3) Dbprintf("ISO14443A Timeout set to %ld (%dms)", timeout, timeout / 106);
 }
 
 
 uint32_t iso14a_get_timeout(void) {
        if(MF_DBGLEVEL >= 3) Dbprintf("ISO14443A Timeout set to %ld (%dms)", timeout, timeout / 106);
 }
 
 
 uint32_t iso14a_get_timeout(void) {

-       return iso14a_timeout + (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/(16*8) - 2;
+       return iso14a_timeout - (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/(16*8) - 2;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -317,15 +319,18 @@ static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time)
                        Uart.startTime -= Uart.syncBit;
                        Uart.endTime = Uart.startTime;
                        Uart.state = STATE_START_OF_COMMUNICATION;
                        Uart.startTime -= Uart.syncBit;
                        Uart.endTime = Uart.startTime;
                        Uart.state = STATE_START_OF_COMMUNICATION;

+                       LED_B_ON();

                }
 
        } else {
 
                if (IsMillerModulationNibble1(Uart.fourBits >> Uart.syncBit)) {                 
                        if (IsMillerModulationNibble2(Uart.fourBits >> Uart.syncBit)) {         // Modulation in both halves - error
                }
 
        } else {
 
                if (IsMillerModulationNibble1(Uart.fourBits >> Uart.syncBit)) {                 
                        if (IsMillerModulationNibble2(Uart.fourBits >> Uart.syncBit)) {         // Modulation in both halves - error

+                               LED_B_OFF();

                                UartReset();
                        } else {                                                                                                                        // Modulation in first half = Sequence Z = logic "0"
                                if (Uart.state == STATE_MILLER_X) {                                                             // error - must not follow after X
                                UartReset();
                        } else {                                                                                                                        // Modulation in first half = Sequence Z = logic "0"
                                if (Uart.state == STATE_MILLER_X) {                                                             // error - must not follow after X

+                                       LED_B_OFF();

                                        UartReset();
                                } else {
                                        Uart.bitCount++;
                                        UartReset();
                                } else {
                                        Uart.bitCount++;


@@ -364,6 +369,7 @@ static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time)
                                }
                        } else {                                                                                                                        // no modulation in both halves - Sequence Y
                                if (Uart.state == STATE_MILLER_Z || Uart.state == STATE_MILLER_Y) {     // Y after logic "0" - End of Communication
                                }
                        } else {                                                                                                                        // no modulation in both halves - Sequence Y
                                if (Uart.state == STATE_MILLER_Z || Uart.state == STATE_MILLER_Y) {     // Y after logic "0" - End of Communication

+                                       LED_B_OFF();

                                        Uart.state = STATE_UNSYNCD;
                                        Uart.bitCount--;                                                                                        // last "0" was part of EOC sequence
                                        Uart.shiftReg <<= 1;                                                                            // drop it
                                        Uart.state = STATE_UNSYNCD;
                                        Uart.bitCount--;                                                                                        // last "0" was part of EOC sequence
                                        Uart.shiftReg <<= 1;                                                                            // drop it


@@ -385,6 +391,7 @@ static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time)
                                        }
                                }
                                if (Uart.state == STATE_START_OF_COMMUNICATION) {                               // error - must not follow directly after SOC
                                        }
                                }
                                if (Uart.state == STATE_START_OF_COMMUNICATION) {                               // error - must not follow directly after SOC

+                                       LED_B_OFF();

                                        UartReset();
                                } else {                                                                                                                // a logic "0"
                                        Uart.bitCount++;
                                        UartReset();
                                } else {                                                                                                                // a logic "0"
                                        Uart.bitCount++;


@@ -490,6 +497,7 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non
                                Demod.startTime -= Demod.syncBit;
                                Demod.bitCount = offset;                        // number of decoded data bits
                                Demod.state = DEMOD_MANCHESTER_DATA;
                                Demod.startTime -= Demod.syncBit;
                                Demod.bitCount = offset;                        // number of decoded data bits
                                Demod.state = DEMOD_MANCHESTER_DATA;

+                               LED_C_ON();

                        }
                }
 
                        }
                }
 


@@ -532,6 +540,7 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non
                                }
                                Demod.endTime = Demod.startTime + 8*(9*Demod.len + Demod.bitCount + 1);
                        } else {                                                                                                        // no modulation in both halves - End of communication
                                }
                                Demod.endTime = Demod.startTime + 8*(9*Demod.len + Demod.bitCount + 1);
                        } else {                                                                                                        // no modulation in both halves - End of communication

+                               LED_C_OFF();

                                if(Demod.bitCount > 0) {                                                                // there are some remaining data bits
                                        Demod.shiftReg >>= (9 - Demod.bitCount);                        // right align the decoded bits
                                        Demod.output[Demod.len++] = Demod.shiftReg & 0xff;      // and add them to the output
                                if(Demod.bitCount > 0) {                                                                // there are some remaining data bits
                                        Demod.shiftReg >>= (9 - Demod.bitCount);                        // right align the decoded bits
                                        Demod.output[Demod.len++] = Demod.shiftReg & 0xff;      // and add them to the output


@@ -572,6 +581,7 @@ void RAMFUNC SnoopIso14443a(uint8_t param) {
        // bit 1 - trigger from first reader 7-bit request
        
        LEDsoff();
        // bit 1 - trigger from first reader 7-bit request
        
        LEDsoff();

+       LED_A_ON();

 
        iso14443a_setup(FPGA_HF_ISO14443A_SNIFFER);
 
 
        iso14443a_setup(FPGA_HF_ISO14443A_SNIFFER);
 


@@ -624,7 +634,6 @@ void RAMFUNC SnoopIso14443a(uint8_t param) {
                        break;
                }
 
                        break;
                }
 

-               LED_A_ON();

                WDT_HIT();
 
                int register readBufDataP = data - dmaBuf;
                WDT_HIT();
 
                int register readBufDataP = data - dmaBuf;


@@ -656,18 +665,15 @@ void RAMFUNC SnoopIso14443a(uint8_t param) {
                        AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
                }
 
                        AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
                }
 

-               LED_A_OFF();
-               

                if (rsamples & 0x01) {                          // Need two samples to feed Miller and Manchester-Decoder
 
                        if(!TagIsActive) {              // no need to try decoding reader data if the tag is sending
                                uint8_t readerdata = (previous_data & 0xF0) | (*data >> 4);
                                if (MillerDecoding(readerdata, (rsamples-1)*4)) {
                if (rsamples & 0x01) {                          // Need two samples to feed Miller and Manchester-Decoder
 
                        if(!TagIsActive) {              // no need to try decoding reader data if the tag is sending
                                uint8_t readerdata = (previous_data & 0xF0) | (*data >> 4);
                                if (MillerDecoding(readerdata, (rsamples-1)*4)) {

-                                       LED_C_ON();
-

                                        // check - if there is a short 7bit request from reader
                                        // check - if there is a short 7bit request from reader

-                                       if ((!triggered) && (param & 0x02) && (Uart.len == 1) && (Uart.bitCount == 7)) triggered = true;
-
+                                       if ((!triggered) && (param & 0x02) && (Uart.len == 1) && (Uart.bitCount == 7)) {
+                                               triggered = true;
+                                       }

                                        if(triggered) {
                                                if (!LogTrace(receivedCmd, 
                                                                                Uart.len, 
                                        if(triggered) {
                                                if (!LogTrace(receivedCmd, 
                                                                                Uart.len, 


@@ -681,31 +687,24 @@ void RAMFUNC SnoopIso14443a(uint8_t param) {
                                        /* And also reset the demod code, which might have been */
                                        /* false-triggered by the commands from the reader. */
                                        DemodReset();
                                        /* And also reset the demod code, which might have been */
                                        /* false-triggered by the commands from the reader. */
                                        DemodReset();

-                                       LED_B_OFF();

                                }
                                ReaderIsActive = (Uart.state != STATE_UNSYNCD);
                        }
 
                                }
                                ReaderIsActive = (Uart.state != STATE_UNSYNCD);
                        }
 

-                       if(!ReaderIsActive) {           // no need to try decoding tag data if the reader is sending - and we cannot afford the time
+                       if (!ReaderIsActive) {          // no need to try decoding tag data if the reader is sending - and we cannot afford the time

                                uint8_t tagdata = (previous_data << 4) | (*data & 0x0F);
                                uint8_t tagdata = (previous_data << 4) | (*data & 0x0F);

-                               if(ManchesterDecoding(tagdata, 0, (rsamples-1)*4)) {
-                                       LED_B_ON();
-
+                               if (ManchesterDecoding(tagdata, 0, (rsamples-1)*4)) {

                                        if (!LogTrace(receivedResponse, 
                                                                        Demod.len, 
                                                                        Demod.startTime*16 - DELAY_TAG_AIR2ARM_AS_SNIFFER, 
                                                                        Demod.endTime*16 - DELAY_TAG_AIR2ARM_AS_SNIFFER,
                                                                        Demod.parity,
                                                                        false)) break;
                                        if (!LogTrace(receivedResponse, 
                                                                        Demod.len, 
                                                                        Demod.startTime*16 - DELAY_TAG_AIR2ARM_AS_SNIFFER, 
                                                                        Demod.endTime*16 - DELAY_TAG_AIR2ARM_AS_SNIFFER,
                                                                        Demod.parity,
                                                                        false)) break;

-

                                        if ((!triggered) && (param & 0x01)) triggered = true;
                                        if ((!triggered) && (param & 0x01)) triggered = true;

-

                                        // And ready to receive another response.
                                        DemodReset();
                                        // And reset the Miller decoder including itS (now outdated) input buffer
                                        UartInit(receivedCmd, receivedCmdPar);
                                        // And ready to receive another response.
                                        DemodReset();
                                        // And reset the Miller decoder including itS (now outdated) input buffer
                                        UartInit(receivedCmd, receivedCmdPar);

-
-                                       LED_C_OFF();

                                } 
                                TagIsActive = (Demod.state != DEMOD_UNSYNCD);
                        }
                                } 
                                TagIsActive = (Demod.state != DEMOD_UNSYNCD);
                        }


@@ -719,12 +718,12 @@ void RAMFUNC SnoopIso14443a(uint8_t param) {
                }
        } // main cycle
 
                }
        } // main cycle
 

-       DbpString("COMMAND FINISHED");
-

        FpgaDisableSscDma();
        FpgaDisableSscDma();

+       LEDsoff();
+
+       DbpString("COMMAND FINISHED");

        Dbprintf("maxDataLen=%d, Uart.state=%x, Uart.len=%d", maxDataLen, Uart.state, Uart.len);
        Dbprintf("traceLen=%d, Uart.output[0]=%08x", BigBuf_get_traceLen(), (uint32_t)Uart.output[0]);
        Dbprintf("maxDataLen=%d, Uart.state=%x, Uart.len=%d", maxDataLen, Uart.state, Uart.len);
        Dbprintf("traceLen=%d, Uart.output[0]=%08x", BigBuf_get_traceLen(), (uint32_t)Uart.output[0]);

-       LEDsoff();

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -1219,7 +1218,7 @@ void SimulateIso14443aTag(int tagType, int uid_1st, int uid_2nd, byte_t* data)
                        EmSendPrecompiledCmd(p_response);
                }
                
                        EmSendPrecompiledCmd(p_response);
                }
                

-               if (!tracing) {
+               if (!get_tracing()) {

                        Dbprintf("Trace Full. Simulation stopped.");
                        break;
                }
                        Dbprintf("Trace Full. Simulation stopped.");
                        break;
                }


@@ -1265,7 +1264,7 @@ static void PrepareDelayedTransfer(uint16_t delay)
 //-------------------------------------------------------------------------------------
 static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing)
 {
 //-------------------------------------------------------------------------------------
 static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing)
 {

-       
+       LED_D_ON();

        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
 
        uint32_t ThisTransferTime = 0;
        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
 
        uint32_t ThisTransferTime = 0;


@@ -1404,7 +1403,7 @@ int EmGetCmd(uint8_t *received, uint16_t *len, uint8_t *parity)
                                ADC_MODE_PRESCALE(63) |
                                ADC_MODE_STARTUP_TIME(1) |
                                ADC_MODE_SAMPLE_HOLD_TIME(15);
                                ADC_MODE_PRESCALE(63) |
                                ADC_MODE_STARTUP_TIME(1) |
                                ADC_MODE_SAMPLE_HOLD_TIME(15);

-       AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ADC_CHAN_HF);
+       AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ADC_CHAN_HF_LOW);

        // start ADC
        AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
        
        // start ADC
        AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
        


@@ -1431,12 +1430,12 @@ int EmGetCmd(uint8_t *received, uint16_t *len, uint8_t *parity)
                if (BUTTON_PRESS()) return 1;
 
                // test if the field exists
                if (BUTTON_PRESS()) return 1;
 
                // test if the field exists

-               if (AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ADC_CHAN_HF)) {
+               if (AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ADC_CHAN_HF_LOW)) {

                        analogCnt++;
                        analogCnt++;

-                       analogAVG += AT91C_BASE_ADC->ADC_CDR[ADC_CHAN_HF];
+                       analogAVG += AT91C_BASE_ADC->ADC_CDR[ADC_CHAN_HF_LOW];

                        AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
                        if (analogCnt >= 32) {
                        AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
                        if (analogCnt >= 32) {

-                               if ((MAX_ADC_HF_VOLTAGE * (analogAVG / analogCnt) >> 10) < MF_MINFIELDV) {
+                               if ((MAX_ADC_HF_VOLTAGE_LOW * (analogAVG / analogCnt) >> 10) < MF_MINFIELDV) {

                                        vtime = GetTickCount();
                                        if (!timer) timer = vtime;
                                        // 50ms no field --> card to idle state
                                        vtime = GetTickCount();
                                        if (!timer) timer = vtime;
                                        // 50ms no field --> card to idle state


@@ -1469,6 +1468,7 @@ static int EmSendCmd14443aRaw(uint8_t *resp, uint16_t respLen)
        bool correctionNeeded;
 
        // Modulate Manchester
        bool correctionNeeded;
 
        // Modulate Manchester

+       LED_D_OFF();

        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_MOD);
 
        // include correction bit if necessary
        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_MOD);
 
        // include correction bit if necessary


@@ -1618,9 +1618,7 @@ void ReaderTransmitBitsPar(uint8_t* frame, uint16_t bits, uint8_t *par, uint32_t
                LED_A_ON();
   
        // Log reader command in trace buffer
                LED_A_ON();
   
        // Log reader command in trace buffer

-       if (tracing) {
-               LogTrace(frame, nbytes(bits), LastTimeProxToAirStart*16 + DELAY_ARM2AIR_AS_READER, (LastTimeProxToAirStart + LastProxToAirDuration)*16 + DELAY_ARM2AIR_AS_READER, par, true);
-       }
+       LogTrace(frame, nbytes(bits), LastTimeProxToAirStart*16 + DELAY_ARM2AIR_AS_READER, (LastTimeProxToAirStart + LastProxToAirDuration)*16 + DELAY_ARM2AIR_AS_READER, par, true);

 }
 
 
 }
 
 


@@ -1651,9 +1649,7 @@ void ReaderTransmit(uint8_t* frame, uint16_t len, uint32_t *timing)
 static int ReaderReceiveOffset(uint8_t* receivedAnswer, uint16_t offset, uint8_t *parity)
 {
        if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, offset)) return false;
 static int ReaderReceiveOffset(uint8_t* receivedAnswer, uint16_t offset, uint8_t *parity)
 {
        if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, offset)) return false;

-       if (tracing) {
-               LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, false);
-       }
+       LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, false);

        return Demod.len;
 }
 
        return Demod.len;
 }
 


@@ -1661,9 +1657,7 @@ static int ReaderReceiveOffset(uint8_t* receivedAnswer, uint16_t offset, uint8_t
 int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity)
 {
        if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, 0)) return false;
 int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity)
 {
        if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, 0)) return false;

-       if (tracing) {
-               LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, false);
-       }
+       LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, false);

        return Demod.len;
 }
 
        return Demod.len;
 }
 


@@ -1776,7 +1770,9 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
                if (anticollision) {
                        // SELECT_ALL
                        ReaderTransmit(sel_all, sizeof(sel_all), NULL);
                if (anticollision) {
                        // SELECT_ALL
                        ReaderTransmit(sel_all, sizeof(sel_all), NULL);

-                       if (!ReaderReceive(resp, resp_par)) return 0;
+                       if (!ReaderReceive(resp, resp_par)) {
+                               return 0;
+                       }

 
                        if (Demod.collisionPos) {                       // we had a collision and need to construct the UID bit by bit
                                memset(uid_resp, 0, 4);
 
                        if (Demod.collisionPos) {                       // we had a collision and need to construct the UID bit by bit
                                memset(uid_resp, 0, 4);


@@ -1798,7 +1794,9 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
                                        }
                                        collision_answer_offset = uid_resp_bits%8;
                                        ReaderTransmitBits(sel_uid, 16 + uid_resp_bits, NULL);
                                        }
                                        collision_answer_offset = uid_resp_bits%8;
                                        ReaderTransmitBits(sel_uid, 16 + uid_resp_bits, NULL);

-                                       if (!ReaderReceiveOffset(resp, collision_answer_offset, resp_par)) return 0;
+                                       if (!ReaderReceiveOffset(resp, collision_answer_offset, resp_par)) {
+                                               return 0;
+                                       }

                                }
                                // finally, add the last bits and BCC of the UID
                                for (uint16_t i = collision_answer_offset; i < (Demod.len-1)*8; i++, uid_resp_bits++) {
                                }
                                // finally, add the last bits and BCC of the UID
                                for (uint16_t i = collision_answer_offset; i < (Demod.len-1)*8; i++, uid_resp_bits++) {


@@ -1832,7 +1830,9 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
                ReaderTransmit(sel_uid, sizeof(sel_uid), NULL);
 
                // Receive the SAK
                ReaderTransmit(sel_uid, sizeof(sel_uid), NULL);
 
                // Receive the SAK

-               if (!ReaderReceive(resp, resp_par)) return 0;
+               if (!ReaderReceive(resp, resp_par)) {
+                       return 0;
+               }

                sak = resp[0];
        
                // Test if more parts of the uid are coming
                sak = resp[0];
        
                // Test if more parts of the uid are coming


@@ -1867,7 +1867,9 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
                AppendCrc14443a(rats, 2);
                ReaderTransmit(rats, sizeof(rats), NULL);
 
                AppendCrc14443a(rats, 2);
                ReaderTransmit(rats, sizeof(rats), NULL);
 

-               if (!(len = ReaderReceive(resp, resp_par))) return 0;
+               if (!(len = ReaderReceive(resp, resp_par))) {
+                       return 0;
+               }

 
                if(p_hi14a_card) {
                        memcpy(p_hi14a_card->ats, resp, len);
 
                if(p_hi14a_card) {
                        memcpy(p_hi14a_card->ats, resp, len);


@@ -1888,7 +1890,7 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
 void iso14443a_setup(uint8_t fpga_minor_mode) {
        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
        // Set up the synchronous serial port
 void iso14443a_setup(uint8_t fpga_minor_mode) {
        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
        // Set up the synchronous serial port

-       FpgaSetupSsc();
+       FpgaSetupSsc(FPGA_MAJOR_MODE_HF_ISO14443A);

        // connect Demodulated Signal to ADC:
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
 
        // connect Demodulated Signal to ADC:
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
 


@@ -1934,15 +1936,24 @@ b8 b7 b6 b5 b4 b3 b2 b1
 b5,b6 = 00 - DESELECT
         11 - WTX 
 */    
 b5,b6 = 00 - DESELECT
         11 - WTX 
 */    

-int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, void *data) {
+int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, bool send_chaining, void *data, uint8_t *res) {

        uint8_t parity[MAX_PARITY_SIZE];
        uint8_t real_cmd[cmd_len + 4];
        
        uint8_t parity[MAX_PARITY_SIZE];
        uint8_t real_cmd[cmd_len + 4];
        

-       // ISO 14443 APDU frame: PCB [CID] [NAD] APDU CRC PCB=0x02
-       real_cmd[0] = 0x02; // bnr,nad,cid,chn=0; i-block(0x00) 
-       // put block number into the PCB
-       real_cmd[0] |= iso14_pcb_blocknum;
-       memcpy(real_cmd + 1, cmd, cmd_len);
+       if (cmd_len) {
+               // ISO 14443 APDU frame: PCB [CID] [NAD] APDU CRC PCB=0x02
+               real_cmd[0] = 0x02; // bnr,nad,cid,chn=0; i-block(0x00) 
+               if (send_chaining) {
+                       real_cmd[0] |= 0x10;
+               }
+               // put block number into the PCB
+               real_cmd[0] |= iso14_pcb_blocknum;
+               memcpy(real_cmd + 1, cmd, cmd_len);
+       } else {
+               // R-block. ACK
+               real_cmd[0] = 0xA2; // r-block + ACK    
+               real_cmd[0] |= iso14_pcb_blocknum;
+       }

        AppendCrc14443a(real_cmd, cmd_len + 1);
  
        ReaderTransmit(real_cmd, cmd_len + 3, NULL);
        AppendCrc14443a(real_cmd, cmd_len + 1);
  
        ReaderTransmit(real_cmd, cmd_len + 3, NULL);


@@ -1954,7 +1965,7 @@ int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, void *data) {
                return 0; //DATA LINK ERROR
        } else{
                // S-Block WTX 
                return 0; //DATA LINK ERROR
        } else{
                // S-Block WTX 

-               while((data_bytes[0] & 0xF2) == 0xF2) {
+               while(len && ((data_bytes[0] & 0xF2) == 0xF2)) {

                        uint32_t save_iso14a_timeout = iso14a_get_timeout();
                        // temporarily increase timeout
                        iso14a_set_timeout(MAX((data_bytes[1] & 0x3f) * save_iso14a_timeout, MAX_ISO14A_TIMEOUT));
                        uint32_t save_iso14a_timeout = iso14a_get_timeout();
                        // temporarily increase timeout
                        iso14a_set_timeout(MAX((data_bytes[1] & 0x3f) * save_iso14a_timeout, MAX_ISO14A_TIMEOUT));


@@ -1981,20 +1992,26 @@ int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, void *data) {
                {
                        iso14_pcb_blocknum ^= 1;
                }
                {
                        iso14_pcb_blocknum ^= 1;
                }

+               
+               // if we received I-block with chaining we need to send ACK and receive another block of data
+               if (res)
+                       *res = data_bytes[0];

 
                // crc check
 
                // crc check

-               if (len >=3 && !CheckCrc14443(CRC_14443_A, data_bytes, len)) {
+               if (len >= 3 && !CheckCrc14443(CRC_14443_A, data_bytes, len)) {

                        return -1;
                }
                
        }
        
                        return -1;
                }
                
        }
        

-       // cut frame byte
-       len -= 1;
-       // memmove(data_bytes, data_bytes + 1, len);
-       for (int i = 0; i < len; i++)
-               data_bytes[i] = data_bytes[i + 1];
-       
+       if (len) {
+               // cut frame byte
+               len -= 1;
+               // memmove(data_bytes, data_bytes + 1, len);
+               for (int i = 0; i < len; i++)
+                       data_bytes[i] = data_bytes[i + 1];
+       }
+               

        return len;
 }
 
        return len;
 }
 


@@ -2037,7 +2054,7 @@ void ReaderIso14443a(UsbCommand *c)
                                // 1 - all is OK with ATS, 2 - without ATS
                                cantSELECT = true;
                        }
                                // 1 - all is OK with ATS, 2 - without ATS
                                cantSELECT = true;
                        }

-                       
+                       FpgaDisableTracing();

                        LED_B_ON();
                        cmd_send(CMD_ACK,arg0,card->uidlen,0,buf,sizeof(iso14a_card_select_t));
                        LED_B_OFF();
                        LED_B_ON();
                        cmd_send(CMD_ACK,arg0,card->uidlen,0,buf,sizeof(iso14a_card_select_t));
                        LED_B_OFF();


@@ -2049,9 +2066,11 @@ void ReaderIso14443a(UsbCommand *c)
        }
 
        if(param & ISO14A_APDU && !cantSELECT) {
        }
 
        if(param & ISO14A_APDU && !cantSELECT) {

-               arg0 = iso14_apdu(cmd, len, buf);
+               uint8_t res;
+               arg0 = iso14_apdu(cmd, len, (param & ISO14A_SEND_CHAINING), buf, &res);
+               FpgaDisableTracing();

                LED_B_ON();
                LED_B_ON();

-               cmd_send(CMD_ACK, arg0, 0, 0, buf, sizeof(buf));
+               cmd_send(CMD_ACK, arg0, res, 0, buf, sizeof(buf));

                LED_B_OFF();
        }
 
                LED_B_OFF();
        }
 


@@ -2091,6 +2110,7 @@ void ReaderIso14443a(UsbCommand *c)
                        }
                }
                arg0 = ReaderReceive(buf, par);
                        }
                }
                arg0 = ReaderReceive(buf, par);

+               FpgaDisableTracing();

 
                LED_B_ON();
                cmd_send(CMD_ACK,arg0,0,0,buf,sizeof(buf));
 
                LED_B_ON();
                cmd_send(CMD_ACK,arg0,0,0,buf,sizeof(buf));


@@ -2150,9 +2170,7 @@ void ReaderMifare(bool first_try)
        uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
        uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
 
        uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
        uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
 

-       if (first_try) { 
-               iso14443a_setup(FPGA_HF_ISO14443A_READER_MOD);
-       }
+       iso14443a_setup(FPGA_HF_ISO14443A_READER_MOD);

        
        // free eventually allocated BigBuf memory. We want all for tracing.
        BigBuf_free();
        
        // free eventually allocated BigBuf memory. We want all for tracing.
        BigBuf_free();


@@ -2160,9 +2178,9 @@ void ReaderMifare(bool first_try)
        clear_trace();
        set_tracing(true);
 
        clear_trace();
        set_tracing(true);
 

-       byte_t nt_diff = 0;
+       uint8_t nt_diff = 0;

        uint8_t par[1] = {0};   // maximum 8 Bytes to be sent here, 1 byte parity is therefore enough
        uint8_t par[1] = {0};   // maximum 8 Bytes to be sent here, 1 byte parity is therefore enough

-       static byte_t par_low = 0;
+       static uint8_t par_low = 0;

        bool led_on = true;
        uint8_t uid[10]  ={0};
        uint32_t cuid;
        bool led_on = true;
        uint8_t uid[10]  ={0};
        uint32_t cuid;


@@ -2170,11 +2188,11 @@ void ReaderMifare(bool first_try)
        uint32_t nt = 0;
        uint32_t previous_nt = 0;
        static uint32_t nt_attacked = 0;
        uint32_t nt = 0;
        uint32_t previous_nt = 0;
        static uint32_t nt_attacked = 0;

-       byte_t par_list[8] = {0x00};
-       byte_t ks_list[8] = {0x00};
+       uint8_t par_list[8] = {0x00};
+       uint8_t ks_list[8] = {0x00};

 
        #define PRNG_SEQUENCE_LENGTH  (1 << 16);
 
        #define PRNG_SEQUENCE_LENGTH  (1 << 16);

-       static uint32_t sync_time;
+       uint32_t sync_time = GetCountSspClk() & 0xfffffff8;

        static int32_t sync_cycles;
        int catch_up_cycles = 0;
        int last_catch_up = 0;
        static int32_t sync_cycles;
        int catch_up_cycles = 0;
        int last_catch_up = 0;


@@ -2184,10 +2202,9 @@ void ReaderMifare(bool first_try)
 
        if (first_try) { 
                mf_nr_ar3 = 0;
 
        if (first_try) { 
                mf_nr_ar3 = 0;

-               sync_time = GetCountSspClk() & 0xfffffff8;
+               par[0] = par_low = 0;

                sync_cycles = PRNG_SEQUENCE_LENGTH;                                                     // theory: Mifare Classic's random generator repeats every 2^16 cycles (and so do the tag nonces).
                nt_attacked = 0;
                sync_cycles = PRNG_SEQUENCE_LENGTH;                                                     // theory: Mifare Classic's random generator repeats every 2^16 cycles (and so do the tag nonces).
                nt_attacked = 0;

-               par[0] = 0;

        }
        else {
                // we were unsuccessful on a previous call. Try another READER nonce (first 3 parity bits remain the same)
        }
        else {
                // we were unsuccessful on a previous call. Try another READER nonce (first 3 parity bits remain the same)


@@ -2203,6 +2220,7 @@ void ReaderMifare(bool first_try)
 
        #define MAX_UNEXPECTED_RANDOM   4               // maximum number of unexpected (i.e. real) random numbers when trying to sync. Then give up.
        #define MAX_SYNC_TRIES                  32
 
        #define MAX_UNEXPECTED_RANDOM   4               // maximum number of unexpected (i.e. real) random numbers when trying to sync. Then give up.
        #define MAX_SYNC_TRIES                  32

+       #define SYNC_TIME_BUFFER                16              // if there is only SYNC_TIME_BUFFER left before next planned sync, wait for next PRNG cycle

        #define NUM_DEBUG_INFOS                 8               // per strategy
        #define MAX_STRATEGY                    3
        uint16_t unexpected_random = 0;
        #define NUM_DEBUG_INFOS                 8               // per strategy
        #define MAX_STRATEGY                    3
        uint16_t unexpected_random = 0;


@@ -2252,8 +2270,8 @@ void ReaderMifare(bool first_try)
                        sync_time = (sync_time & 0xfffffff8) + sync_cycles + catch_up_cycles;
                        catch_up_cycles = 0;
 
                        sync_time = (sync_time & 0xfffffff8) + sync_cycles + catch_up_cycles;
                        catch_up_cycles = 0;
 

-                       // if we missed the sync time already, advance to the next nonce repeat
-                       while(GetCountSspClk() > sync_time) {
+                       // if we missed the sync time already or are about to miss it, advance to the next nonce repeat
+                       while(sync_time < GetCountSspClk() + SYNC_TIME_BUFFER) {

                                elapsed_prng_sequences++;
                                sync_time = (sync_time & 0xfffffff8) + sync_cycles;
                        }
                                elapsed_prng_sequences++;
                                sync_time = (sync_time & 0xfffffff8) + sync_cycles;
                        }


@@ -2409,14 +2427,16 @@ void ReaderMifare(bool first_try)
                }
        }
        
                }
        }
        

-       byte_t buf[28];
+       FpgaDisableTracing();
+
+       uint8_t buf[32];

        memcpy(buf + 0,  uid, 4);
        num_to_bytes(nt, 4, buf + 4);
        memcpy(buf + 8,  par_list, 8);
        memcpy(buf + 16, ks_list, 8);
        memcpy(buf + 0,  uid, 4);
        num_to_bytes(nt, 4, buf + 4);
        memcpy(buf + 8,  par_list, 8);
        memcpy(buf + 16, ks_list, 8);

-       memcpy(buf + 24, mf_nr_ar, 4);
+       memcpy(buf + 24, mf_nr_ar, 8);

                
                

-       cmd_send(CMD_ACK, isOK, 0, 0, buf, 28);
+       cmd_send(CMD_ACK, isOK, 0, 0, buf, 32);

 
        // Thats it...
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
 
        // Thats it...
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);


@@ -2437,6 +2457,8 @@ void RAMFUNC SniffMifare(uint8_t param) {
 
        // C(red) A(yellow) B(green)
        LEDsoff();
 
        // C(red) A(yellow) B(green)
        LEDsoff();

+       LED_A_ON();
+       

        // init trace buffer
        clear_trace();
        set_tracing(true);
        // init trace buffer
        clear_trace();
        set_tracing(true);


@@ -2472,8 +2494,6 @@ void RAMFUNC SniffMifare(uint8_t param) {
        // Setup for the DMA.
        FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE); // set transfer address and number of bytes. Start transfer.
 
        // Setup for the DMA.
        FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE); // set transfer address and number of bytes. Start transfer.
 

-       LED_D_OFF();
-       

        // init sniffer
        MfSniffInit();
 
        // init sniffer
        MfSniffInit();
 


@@ -2481,11 +2501,10 @@ void RAMFUNC SniffMifare(uint8_t param) {
        for(uint32_t sniffCounter = 0; true; ) {
        
                if(BUTTON_PRESS()) {
        for(uint32_t sniffCounter = 0; true; ) {
        
                if(BUTTON_PRESS()) {

-                       DbpString("cancelled by button");
+                       DbpString("Canceled by button.");

                        break;
                }
 
                        break;
                }
 

-               LED_A_ON();

                WDT_HIT();
                
                if ((sniffCounter & 0x0000FFFF) == 0) { // from time to time
                WDT_HIT();
                
                if ((sniffCounter & 0x0000FFFF) == 0) { // from time to time


@@ -2531,14 +2550,12 @@ void RAMFUNC SniffMifare(uint8_t param) {
                        AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
                }
 
                        AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
                }
 

-               LED_A_OFF();
-               

                if (sniffCounter & 0x01) {
 
                        if(!TagIsActive) {              // no need to try decoding tag data if the reader is sending
                                uint8_t readerdata = (previous_data & 0xF0) | (*data >> 4);
                                if(MillerDecoding(readerdata, (sniffCounter-1)*4)) {
                if (sniffCounter & 0x01) {
 
                        if(!TagIsActive) {              // no need to try decoding tag data if the reader is sending
                                uint8_t readerdata = (previous_data & 0xF0) | (*data >> 4);
                                if(MillerDecoding(readerdata, (sniffCounter-1)*4)) {

-                                       LED_C_INV();
+

                                        if (MfSniffLogic(receivedCmd, Uart.len, Uart.parity, Uart.bitCount, true)) break;
 
                                        /* And ready to receive another command. */
                                        if (MfSniffLogic(receivedCmd, Uart.len, Uart.parity, Uart.bitCount, true)) break;
 
                                        /* And ready to receive another command. */


@@ -2553,7 +2570,6 @@ void RAMFUNC SniffMifare(uint8_t param) {
                        if(!ReaderIsActive) {           // no need to try decoding tag data if the reader is sending
                                uint8_t tagdata = (previous_data << 4) | (*data & 0x0F);
                                if(ManchesterDecoding(tagdata, 0, (sniffCounter-1)*4)) {
                        if(!ReaderIsActive) {           // no need to try decoding tag data if the reader is sending
                                uint8_t tagdata = (previous_data << 4) | (*data & 0x0F);
                                if(ManchesterDecoding(tagdata, 0, (sniffCounter-1)*4)) {

-                                       LED_C_INV();

 
                                        if (MfSniffLogic(receivedResponse, Demod.len, Demod.parity, Demod.bitCount, false)) break;
 
 
                                        if (MfSniffLogic(receivedResponse, Demod.len, Demod.parity, Demod.bitCount, false)) break;
 


@@ -2575,11 +2591,13 @@ void RAMFUNC SniffMifare(uint8_t param) {
 
        } // main cycle
 
 
        } // main cycle
 

-       DbpString("COMMAND FINISHED");
-
+       FpgaDisableTracing();

        FpgaDisableSscDma();
        FpgaDisableSscDma();

+       LEDsoff();
+
+       DbpString("COMMAND FINISHED.");
+

        MfSniffEnd();
        
        Dbprintf("maxDataLen=%x, Uart.state=%x, Uart.len=%x", maxDataLen, Uart.state, Uart.len);
        MfSniffEnd();
        
        Dbprintf("maxDataLen=%x, Uart.state=%x, Uart.len=%x", maxDataLen, Uart.state, Uart.len);

-       LEDsoff();

 }
 }