CHG: changed to use BigBuff_Eml memory instead of big_buff_malloc.

CHG: downloading eml memory from device should use uint's
CHG: "hf legic read" has a different printing. It now prints 32bytes / row

diff --git a/armsrc/legicrf.c b/armsrc/legicrf.c
index b1c6b1964103bd92666414bdcbf4c4703d44a1f9..63799c7bcaac39022120ffa3790ad13b3a164804 100644 (file)
--- a/armsrc/legicrf.c
+++ b/armsrc/legicrf.c
@@ -72,7 +72,7 @@ static void setup_timer(void) {
 #define        RWD_TIME_1 120          // READER_TIME_PAUSE 20us off, 80us on = 100us  80 * 1.5 == 120ticks
 #define RWD_TIME_0 60          // READER_TIME_PAUSE 20us off, 40us on = 60us   40 * 1.5 == 60ticks 
 #define RWD_TIME_PAUSE 30      // 20us == 20 * 1.5 == 30ticks */
-#define TAG_BIT_PERIOD 142     // 100us == 100 * 1.5 == 150ticks
+#define TAG_BIT_PERIOD 144     // 100us == 100 * 1.5 == 150ticks
 #define TAG_FRAME_WAIT 495  // 330us from READER frame end to TAG frame start. 330 * 1.5 == 495
 
 #define RWD_TIME_FUZZ 20   // rather generous 13us, since the peak detector + hysteresis fuzz quite a bit
@@ -279,13 +279,9 @@ static void frame_receiveAsReader(struct legic_frame * const f, uint8_t bits) {
        
        //FIXED time between sending frame and now listening frame. 330us
        uint32_t starttime = GET_TICKS;
-       //if ( bits == 6 || bits == 7) {
-               // its about 9+9 ticks delay from end-send to here.
-               //WaitTicks( 495 - 9 - 9 );             
-               WaitTicks( 477 );
-       //} else {
-//             WaitTicks( 477 );
-//     }
+       // its about 9+9 ticks delay from end-send to here.
+       //WaitTicks( 495 - 9 - 9 );             
+       WaitTicks( 477 );
 
        next_bit_at = GET_TICKS + TAG_BIT_PERIOD;
 
@@ -324,7 +320,7 @@ static uint32_t setup_phase_reader(uint8_t iv) {
        
        // Switch on carrier and let the tag charge for 1ms
        HIGH(GPIO_SSC_DOUT);
-       WaitUS(1000);   
+       WaitUS(2000);   
        
        ResetTicks();
        
@@ -370,7 +366,7 @@ static void LegicCommonInit(void) {
        AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
 
        // reserve a cardmem,  meaning we can use the tracelog function in bigbuff easier.
-       cardmem = BigBuf_malloc(LEGIC_CARD_MEMSIZE);
+       cardmem = BigBuf_get_EM_addr();
        memset(cardmem, 0x00, LEGIC_CARD_MEMSIZE);
 
        clear_trace();
@@ -402,7 +398,6 @@ int legic_read_byte( uint16_t index, uint8_t cmd_sz) {
 
        //WaitTicks(366); 
        WaitTicks(330); 
-       //WaitTicks(50);
        
        frame_sendAsReader(cmd, cmd_sz);
        frame_receiveAsReader(&current_frame, 12);
@@ -457,7 +452,7 @@ int legic_write_byte(uint8_t byte, uint16_t addr, uint8_t addr_sz) {
        
        frame_sendAsReader(cmd, cmd_sz);
   
-       // wllm-rbnt doesnt have these
+ 
        AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
        AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
 
@@ -471,13 +466,13 @@ int legic_write_byte(uint8_t byte, uint16_t addr, uint8_t addr_sz) {
         edges = 0;
                next_bit_at += TAG_BIT_PERIOD;
         while(timer->TC_CV < next_bit_at) {
-            int level = (AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN);
+            volatile uint32_t level = (AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN);
             if(level != old_level)
                 edges++;
 
             old_level = level;
         }
-        if(edges > 20 && edges < 60) { /* expected are 42 edges */
+        if(edges > 20 ) { /* expected are 42 edges */
                        int t = timer->TC_CV;
                        int c = t / TAG_BIT_PERIOD;
                        
@@ -618,6 +613,7 @@ void LegicRfWriter(uint16_t offset, uint16_t bytes, uint8_t iv) {
 
     LED_B_ON();
        setup_phase_reader(iv);
+       
        int r = 0;
        while(byte_index < bytes) {
 

diff --git a/client/cmdhflegic.c b/client/cmdhflegic.c
index f0fb12be8b7973ed1d2db94eb7925e35a60ccc55..5bfa9eaf8fa6c725be86f52352859819ee1dccab 100644 (file)
--- a/client/cmdhflegic.c
+++ b/client/cmdhflegic.c
@@ -414,7 +414,7 @@ int CmdLegicRFRead(const char *Cmd) {
                PrintAndLog("LSB of IV must be SET");   
        }
 
-       //PrintAndLog("Using IV: 0x%02x | Offset: 0x%02x | Len: 0x%02x ", IV, offset, len);
+       //PrintAndLog("Using IV: 0x%02x", IV);
        
        UsbCommand c = {CMD_READER_LEGIC_RF, {offset, len, IV}};
        clearCommandBuffer();
@@ -424,12 +424,24 @@ int CmdLegicRFRead(const char *Cmd) {
                uint8_t isOK = resp.arg[0] & 0xFF;
                uint16_t len = resp.arg[1] & 0x3FF;
                 if ( isOK ) {
-                       PrintAndLog("use 'hf legic decode'");
 
-                       uint8_t *data = resp.d.asBytes;
-                       PrintAndLog("\nData        |");
+                       uint8_t *data = malloc(len);
+                       if ( !data ){
+                               PrintAndLog("Cannot allocate memory");
+                               return 2;
+                       }
+                       // copy data from device
+                       GetEMLFromBigBuf(data, len, 0);
+                       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2000)){
+                               PrintAndLog("Command execute timeout");
+                               if ( data ) 
+                                       free(data);
+                               return 1;
+                       }
+       
+                       PrintAndLog("\nData");
                        PrintAndLog("-----------------------------");
-                       PrintAndLog(" %s|\n", sprint_hex(data, len));
+                       print_hex_break( data, len, 32);
                 } else {
                         PrintAndLog("failed reading tag");
                 }

diff --git a/client/data.c b/client/data.c
index 4903476924354bcf4fbb97691bf3737dd8004a3d..184a63b61220ae06e9fea5c29b3754101d95b2fa 100644 (file)
--- a/client/data.c
+++ b/client/data.c
@@ -23,7 +23,7 @@ void GetFromBigBuf(uint8_t *dest, int bytes, int start_index) {
        clearCommandBuffer();
        SendCommand(&c);
 }
-void GetEMLFromBigBuf(uint8_t *dest, int bytes, int start_index) {
+void GetEMLFromBigBuf(uint8_t *dest, uint32_t bytes, uint32_t start_index) {
        sample_buf = dest;
        UsbCommand c = {CMD_DOWNLOAD_EML_BIGBUF, {start_index, bytes, 0}};
        clearCommandBuffer();

diff --git a/client/data.h b/client/data.h
index d156a0c846f5d10b5b7faf6ee01a89f2a587021e..df1f31de3f344ee375b3547599303bb91187c6cb 100644 (file)
--- a/client/data.h
+++ b/client/data.h
@@ -14,5 +14,5 @@
 #include "util.h"
 extern uint8_t* sample_buf;
 void GetFromBigBuf(uint8_t *dest, int bytes, int start_index);
-void GetEMLFromBigBuf(uint8_t *dest, int bytes, int start_index);
+void GetEMLFromBigBuf(uint8_t *dest, uint32_t bytes, uint32_t start_index);
 #endif