X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/111c6934d4e5c58883d08210399afe8eaeccc5c3..d7e24e7c5f3481a45d79de49ad3de2ef0d81437e:/armsrc/legicrf.c?ds=sidebyside diff --git a/armsrc/legicrf.c b/armsrc/legicrf.c index 572a870e..d2e2e856 100644 --- a/armsrc/legicrf.c +++ b/armsrc/legicrf.c @@ -7,7 +7,6 @@ //----------------------------------------------------------------------------- // LEGIC RF simulation code //----------------------------------------------------------------------------- - #include "legicrf.h" static struct legic_frame { @@ -69,15 +68,11 @@ static void setup_timer(void) { */ // At TIMER_CLOCK3 (MCK/32) -//#define RWD_TIME_1 150 /* RWD_TIME_PAUSE off, 80us on = 100us */ -//#define RWD_TIME_0 90 /* RWD_TIME_PAUSE off, 40us on = 60us */ -//#define RWD_TIME_PAUSE 30 /* 20us */ - -// testing calculating in ticks instead of (us) microseconds. +// testing calculating in (us) microseconds. #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 150 // 100us == 100 * 1.5 == 150ticks +#define TAG_BIT_PERIOD 143 // 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 @@ -90,30 +85,26 @@ static void setup_timer(void) { #define FUZZ_EQUAL(value, target, fuzz) ((value) > ((target)-(fuzz)) && (value) < ((target)+(fuzz))) #ifndef SHORT_COIL -//#define LOW(x) AT91C_BASE_PIOA->PIO_CODR = (x) # define SHORT_COIL LOW(GPIO_SSC_DOUT); #endif #ifndef OPEN_COIL -//#define HIGH(x) AT91C_BASE_PIOA->PIO_SODR = (x) # define OPEN_COIL HIGH(GPIO_SSC_DOUT); #endif -uint32_t stop_send_frame_us = 0; +uint32_t sendFrameStop = 0; // Pause pulse, off in 20us / 30ticks, // ONE / ZERO bit pulse, // one == 80us / 120ticks // zero == 40us / 60ticks #ifndef COIL_PULSE -# define COIL_PULSE(x) { \ +# define COIL_PULSE(x) \ + do { \ SHORT_COIL; \ - Wait(RWD_TIME_PAUSE); \ + WaitTicks( (RWD_TIME_PAUSE) ); \ OPEN_COIL; \ - Wait((x)); \ - } -#endif -#ifndef GET_TICKS -# define GET_TICKS AT91C_BASE_TC0->TC_CV + WaitTicks((x)); \ + } while (0) #endif // ToDo: define a meaningful maximum size for auth_table. The bigger this is, the lower will be the available memory for traces. @@ -121,23 +112,7 @@ uint32_t stop_send_frame_us = 0; #define LEGIC_CARD_MEMSIZE 1024 static uint8_t* cardmem; -static void Wait(uint32_t time){ - if ( time == 0 ) return; - time += GET_TICKS; - while (GET_TICKS < time); -} -// Starts Clock and waits until its reset -static void Reset(AT91PS_TC clock){ - clock->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; - while(clock->TC_CV > 1) ; -} - -// Starts Clock and waits until its reset -static void ResetClock(void){ - Reset(timer); -} - -static void frame_append_bit(struct legic_frame * const f, int bit) { +static void frame_append_bit(struct legic_frame * const f, uint8_t bit) { // Overflow, won't happen if (f->bits >= 31) return; @@ -154,7 +129,7 @@ static void frame_clean(struct legic_frame * const f) { // and while sending/receiving in bit frames (100, 60) /*static void CalibratePrng( uint32_t time){ // Calculate Cycles based on timer 100us - uint32_t i = (time - stop_send_frame_us) / 100 ; + uint32_t i = (time - sendFrameStop) / 100 ; // substract cycles of finished frames int k = i - legic_prng_count()+1; @@ -166,8 +141,7 @@ static void frame_clean(struct legic_frame * const f) { */ /* Generate Keystream */ -static uint32_t get_key_stream(int skip, int count) -{ +uint32_t get_key_stream(int skip, int count) { uint32_t key = 0; int i; @@ -175,7 +149,7 @@ static uint32_t get_key_stream(int skip, int count) legic_prng_bc += prng_timer->TC_CV; // reset the prng timer. - Reset(prng_timer); + ResetTimer(prng_timer); /* If skip == -1, forward prng time based */ if(skip == -1) { @@ -209,7 +183,7 @@ static uint32_t get_key_stream(int skip, int count) /* Send a frame in tag mode, the FPGA must have been set up by * LegicRfSimulate */ -static void frame_send_tag(uint16_t response, uint8_t bits, uint8_t crypt) { +void frame_send_tag(uint16_t response, uint8_t bits, uint8_t crypt) { /* Bitbang the response */ LOW(GPIO_SSC_DOUT); AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT; @@ -222,7 +196,7 @@ static void frame_send_tag(uint16_t response, uint8_t bits, uint8_t crypt) { } /* Wait for the frame start */ - Wait( TAG_FRAME_WAIT ); + WaitUS( TAG_FRAME_WAIT ); uint8_t bit = 0; for(int i = 0; i < bits; i++) { @@ -235,7 +209,7 @@ static void frame_send_tag(uint16_t response, uint8_t bits, uint8_t crypt) { else LOW(GPIO_SSC_DOUT); - Wait(100); + WaitUS(100); } LOW(GPIO_SSC_DOUT); } @@ -243,11 +217,11 @@ static void frame_send_tag(uint16_t response, uint8_t bits, uint8_t crypt) { /* Send a frame in reader mode, the FPGA must have been set up by * LegicRfReader */ -static void frame_sendAsReader(uint32_t data, uint8_t bits){ +void frame_sendAsReader(uint32_t data, uint8_t bits){ uint32_t starttime = GET_TICKS, send = 0; uint16_t mask = 1; - uint8_t prng1 = legic_prng_count() ; + uint8_t prngstart = legic_prng_count() ; // xor lsfr onto data. send = data ^ legic_prng_get_bits(bits); @@ -263,15 +237,17 @@ static void frame_sendAsReader(uint32_t data, uint8_t bits){ // Final pause to mark the end of the frame COIL_PULSE(0); - stop_send_frame_us = GET_TICKS; + sendFrameStop = GET_TICKS; uint8_t cmdbytes[] = { + bits, BYTEx(data, 0), BYTEx(data, 1), - bits, - prng1, + BYTEx(send, 0), + BYTEx(send, 1), + prngstart, legic_prng_count() }; - LogTrace(cmdbytes, sizeof(cmdbytes), starttime, stop_send_frame_us, NULL, TRUE); + LogTrace(cmdbytes, sizeof(cmdbytes), starttime, sendFrameStop, NULL, TRUE); } /* Receive a frame from the card in reader emulation mode, the FPGA and @@ -298,35 +274,39 @@ static void frame_sendAsReader(uint32_t data, uint8_t bits){ static void frame_receiveAsReader(struct legic_frame * const f, uint8_t bits) { frame_clean(f); + if ( bits > 32 ) return; - uint8_t i = 0, edges = 0; + uint8_t i = bits, edges = 0; uint16_t lsfr = 0; - uint32_t the_bit = 1, next_bit_at = 0, data; + uint32_t the_bit = 1, next_bit_at = 0, data = 0; + int old_level = 0, level = 0; - - if(bits > 32) bits = 32; - + AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN; AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN; - // calibrate the prng. + // calibrate the prng. legic_prng_forward(2); - - // precompute the cipher - uint8_t prng_before = legic_prng_count() ; - - lsfr = legic_prng_get_bits(bits); - - data = lsfr; + uint8_t prngstart = legic_prng_count() ; + data = lsfr = legic_prng_get_bits(bits); //FIXED time between sending frame and now listening frame. 330us - Wait( TAG_FRAME_WAIT ); - + // 387 = 0x19 0001 1001 uint32_t starttime = GET_TICKS; - + //uint16_t mywait = TAG_FRAME_WAIT - (starttime - sendFrameStop); + //uint16_t mywait = 495 - (starttime - sendFrameStop); + if ( bits == 6) { + //WaitTicks( 495 - 9 - 9 ); + WaitTicks( 475 ); + } else { + //Dbprintf("x WAIT %d", mywait ); + //WaitTicks( mywait ); + WaitTicks( 450 ); + } + next_bit_at = GET_TICKS + TAG_BIT_PERIOD; - - for( i = 0; i < bits; i++) { + + while ( i-- ){ edges = 0; while ( GET_TICKS < next_bit_at) { @@ -336,43 +316,42 @@ static void frame_receiveAsReader(struct legic_frame * const f, uint8_t bits) { ++edges; old_level = level; - } + } + next_bit_at += TAG_BIT_PERIOD; // We expect 42 edges == ONE - if(edges > 20 && edges < 60) { + //if (edges > 20 && edges < 64) + if ( edges > 20 ) data ^= the_bit; - } - the_bit <<= 1; + + the_bit <<= 1; } // output f->data = data; f->bits = bits; - - // log - stop_send_frame_us = GET_TICKS; - uint8_t cmdbytes[] = { - BYTEx(data,0), - BYTEx(data,1), + uint8_t cmdbytes[] = { bits, - BYTEx(lsfr,0), - BYTEx(lsfr,1), - prng_before, + BYTEx(data, 0), + BYTEx(data, 1), + BYTEx(data, 0) ^ BYTEx(lsfr, 0), + BYTEx(data, 1) ^ BYTEx(lsfr, 1), + prngstart, legic_prng_count() }; - LogTrace(cmdbytes, sizeof(cmdbytes), starttime, stop_send_frame_us, NULL, FALSE); + LogTrace(cmdbytes, sizeof(cmdbytes), starttime, GET_TICKS, NULL, FALSE); } // Setup pm3 as a Legic Reader -static uint32_t perform_setup_phase_rwd(uint8_t iv) { - +static uint32_t setup_phase_reader(uint8_t iv) { + // Switch on carrier and let the tag charge for 1ms HIGH(GPIO_SSC_DOUT); - SpinDelay(40); + WaitUS(1000); - ResetUSClock(); + ResetTicks(); // no keystream yet legic_prng_init(0); @@ -385,32 +364,30 @@ static uint32_t perform_setup_phase_rwd(uint8_t iv) { frame_receiveAsReader(¤t_frame, 6); - // fixed delay before sending ack. - Wait(TAG_FRAME_WAIT); - legic_prng_forward(4); + // 292us (438t) - fixed delay before sending ack. + // minus log and stuff 100tick? + WaitTicks(338); + legic_prng_forward(3); // Send obsfuscated acknowledgment frame. // 0x19 = 0x18 MIM22, 0x01 LSB READCMD // 0x39 = 0x38 MIM256, MIM1024 0x01 LSB READCMD switch ( current_frame.data ) { - case 0x0D: - frame_sendAsReader(0x19, 6); - break; - case 0x1D: - case 0x3D: - frame_sendAsReader(0x39, 6); - break; - default: - break; + case 0x0D: frame_sendAsReader(0x19, 6); break; + case 0x1D: + case 0x3D: frame_sendAsReader(0x39, 6); break; + default: break; } + + legic_prng_forward(2); return current_frame.data; } -static void LegicCommonInit(void) { +static void LegicCommonInit(void) { + FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_TX); SetAdcMuxFor(GPIO_MUXSEL_HIPKD); - FpgaSetupSsc(); /* Bitbang the transmitter */ LOW(GPIO_SSC_DOUT); @@ -425,13 +402,13 @@ static void LegicCommonInit(void) { set_tracing(TRUE); crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0); - StartCountUS(); + StartTicks(); } // Switch off carrier, make sure tag is reset static void switch_off_tag_rwd(void) { LOW(GPIO_SSC_DOUT); - SpinDelay(10); + WaitUS(20); WDT_HIT(); } @@ -439,23 +416,30 @@ static void switch_off_tag_rwd(void) { // 5,8,10 address size. static uint32_t legic4Crc(uint8_t legicCmd, uint16_t byte_index, uint8_t value, uint8_t cmd_sz) { crc_clear(&legic_crc); - uint32_t temp = (value << cmd_sz) | (byte_index << 1) | legicCmd; - crc_update(&legic_crc, temp, cmd_sz + 8 ); + //uint32_t temp = (value << cmd_sz) | (byte_index << 1) | legicCmd; + //crc_update(&legic_crc, temp, cmd_sz + 8 ); + crc_update(&legic_crc, 1, 1); /* CMD_READ */ + crc_update(&legic_crc, byte_index, cmd_sz-1); + crc_update(&legic_crc, value, 8); return crc_finish(&legic_crc); } int legic_read_byte(int byte_index, int cmd_sz) { - uint8_t byte = 0, crc = 0; - uint32_t calcCrc = 0; + uint8_t byte = 0, crc = 0, calcCrc = 0; uint32_t cmd = (byte_index << 1) | LEGIC_READ; - - Wait(TAG_FRAME_WAIT); + + // (us)| ticks + // ------------- + // 330 | 495 + // 244 | 366 + WaitTicks(366); frame_sendAsReader(cmd, cmd_sz); frame_receiveAsReader(¤t_frame, 12); byte = BYTEx(current_frame.data, 0); + calcCrc = legic4Crc(LEGIC_READ, byte_index, byte, cmd_sz); crc = BYTEx(current_frame.data, 1); @@ -463,7 +447,9 @@ int legic_read_byte(int byte_index, int cmd_sz) { Dbprintf("!!! crc mismatch: expected %x but got %x !!!", calcCrc, crc); return -1; } + legic_prng_forward(4); + WaitTicks(40); return byte; } @@ -499,7 +485,7 @@ int legic_write_byte(uint8_t byte, uint16_t addr, uint8_t addr_sz) { legic_prng_forward(2); /* we wait anyways */ - Wait(TAG_FRAME_WAIT); + WaitUS(TAG_FRAME_WAIT); frame_sendAsReader(cmd, cmd_sz); @@ -511,7 +497,7 @@ int legic_write_byte(uint8_t byte, uint16_t addr, uint8_t addr_sz) { int t, old_level = 0, edges = 0; int next_bit_at = 0; - Wait(TAG_FRAME_WAIT); + WaitUS(TAG_FRAME_WAIT); for( t = 0; t < 80; ++t) { edges = 0; @@ -527,30 +513,26 @@ int legic_write_byte(uint8_t byte, uint16_t addr, uint8_t addr_sz) { int t = timer->TC_CV; int c = t / TAG_BIT_PERIOD; - ResetClock(); + ResetTimer(timer); legic_prng_forward(c); return 0; } } - ResetClock(); + ResetTimer(timer); return -1; } int LegicRfReader(int offset, int bytes, int iv) { uint16_t byte_index = 0; - uint8_t cmd_sz = 0; - int card_sz = 0; + uint8_t cmd_sz = 0, isOK = 1; + int card_sz = 0; - if ( MF_DBGLEVEL >= 2) - Dbprintf("setting up legic card, IV = 0x%03.3x", iv); - LegicCommonInit(); - uint32_t tag_type = perform_setup_phase_rwd(iv); - - //we lose to mutch time with dprintf + uint32_t tag_type = setup_phase_reader(iv); + switch_off_tag_rwd(); switch(tag_type) { @@ -571,7 +553,9 @@ int LegicRfReader(int offset, int bytes, int iv) { break; default: if ( MF_DBGLEVEL >= 1) Dbprintf("Unknown card format: %x", tag_type); - return 1; + isOK = 0; + goto OUT; + break; } if (bytes == -1) bytes = card_sz; @@ -580,28 +564,27 @@ int LegicRfReader(int offset, int bytes, int iv) { bytes = card_sz - offset; // Start setup and read bytes. - perform_setup_phase_rwd(iv); - + setup_phase_reader(iv); + LED_B_ON(); while (byte_index < bytes) { int r = legic_read_byte(byte_index + offset, cmd_sz); if (r == -1 || BUTTON_PRESS()) { - switch_off_tag_rwd(); - LEDsoff(); - if ( MF_DBGLEVEL >= 2) DbpString("operation aborted"); - cmd_send(CMD_ACK,0,0,0,0,0); - return 1; + if ( MF_DBGLEVEL >= 3) DbpString("operation aborted"); + isOK = 0; + goto OUT; } cardmem[++byte_index] = r; - //byte_index++; WDT_HIT(); } +OUT: + WDT_HIT(); switch_off_tag_rwd(); LEDsoff(); uint8_t len = (bytes & 0x3FF); - cmd_send(CMD_ACK,1,len,0,0,0); + cmd_send(CMD_ACK,isOK,len,0,cardmem,len); return 0; } @@ -609,7 +592,7 @@ int LegicRfReader(int offset, int bytes, int iv) { int byte_index=0; LED_B_ON(); - perform_setup_phase_rwd(iv); + setup_phase_reader(iv); //legic_prng_forward(2); while(byte_index < bytes) { int r; @@ -654,7 +637,7 @@ void LegicRfWriter(int offset, int bytes, int iv) { if ( MF_DBGLEVEL >= 2) DbpString("setting up legic card"); - uint32_t tag_type = perform_setup_phase_rwd(iv); + uint32_t tag_type = setup_phase_reader(iv); switch_off_tag_rwd(); @@ -689,7 +672,7 @@ void LegicRfWriter(int offset, int bytes, int iv) { } LED_B_ON(); - perform_setup_phase_rwd(iv); + setup_phase_reader(iv); int r = 0; while(byte_index < bytes) { @@ -730,7 +713,7 @@ void LegicRfRawWriter(int address, int byte, int iv) { if ( MF_DBGLEVEL >= 2) DbpString("setting up legic card"); - uint32_t tag_type = perform_setup_phase_rwd(iv); + uint32_t tag_type = setup_phase_reader(iv); switch_off_tag_rwd(); @@ -767,7 +750,7 @@ void LegicRfRawWriter(int address, int byte, int iv) { Dbprintf("integer value: %d address: %d addr_sz: %d", byte, address, addr_sz); LED_B_ON(); - perform_setup_phase_rwd(iv); + setup_phase_reader(iv); int r = legic_write_byte(byte, address, addr_sz); @@ -782,6 +765,49 @@ void LegicRfRawWriter(int address, int byte, int iv) { if ( MF_DBGLEVEL >= 1) DbpString("write successful"); } +void LegicRfInfo(void){ + + LegicCommonInit(); + uint32_t tag_type = setup_phase_reader(0x1); + uint8_t cmd_sz = 0; + uint16_t card_sz = 0; + + switch(tag_type) { + case 0x0d: + cmd_sz = 6; + card_sz = 22; + break; + case 0x1d: + cmd_sz = 9; + card_sz = 256; + break; + case 0x3d: + cmd_sz = 11; + card_sz = 1024; + break; + default: + cmd_send(CMD_ACK,0,0,0,0,0); + goto OUT; + } + + // read UID bytes. + uint8_t uid[] = {0,0,0,0}; + for ( uint8_t i = 0; i < sizeof(uid); ++i) { + int r = legic_read_byte(i, cmd_sz); + if ( r == -1 ) { + cmd_send(CMD_ACK,0,0,0,0,0); + goto OUT; + } + uid[i] = r & 0xFF; + } + + cmd_send(CMD_ACK,1,card_sz,0,uid,sizeof(uid)); +OUT: + switch_off_tag_rwd(); + LEDsoff(); + +} + /* Handle (whether to respond) a frame in tag mode * Only called when simulating a tag. */ @@ -795,7 +821,7 @@ static void frame_handle_tag(struct legic_frame const * const f) LED_C_ON(); // Reset prng timer - Reset(prng_timer); + ResetTimer(prng_timer); legic_prng_init(f->data); frame_send_tag(0x3d, 6, 1); /* 0x3d^0x26 = 0x1B */ @@ -805,8 +831,8 @@ static void frame_handle_tag(struct legic_frame const * const f) legic_prng_iv = f->data; - ResetClock(); - Wait(280); + ResetTimer(timer); + WaitUS(280); return; } @@ -817,8 +843,8 @@ static void frame_handle_tag(struct legic_frame const * const f) if((f->bits == 6) && (f->data == xored)) { legic_state = STATE_CON; - ResetClock(); - Wait(200); + ResetTimer(timer); + WaitUS(200); return; } else { @@ -844,9 +870,9 @@ static void frame_handle_tag(struct legic_frame const * const f) frame_send_tag(hash | data, 12, 1); - ResetClock(); + ResetTimer(timer); legic_prng_forward(2); - Wait(180); + WaitUS(180); return; } } @@ -997,10 +1023,6 @@ void LegicRfSimulate(int phase, int frame, int reqresp) LEDsoff(); } -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- - - //----------------------------------------------------------------------------- // Code up a string of octets at layer 2 (including CRC, we don't generate // that here) so that they can be transmitted to the reader. Doesn't transmit @@ -1092,6 +1114,7 @@ void LegicRfSimulate(int phase, int frame, int reqresp) // The software UART that receives commands from the reader, and its state // variables. //----------------------------------------------------------------------------- +/* static struct { enum { STATE_UNSYNCD, @@ -1106,7 +1129,7 @@ static struct { int posCnt; uint8_t *output; } Uart; - +*/ /* Receive & handle a bit coming from the reader. * * This function is called 4 times per bit (every 2 subcarrier cycles). @@ -1231,7 +1254,7 @@ static struct { // return FALSE; // } - +/* static void UartReset() { Uart.byteCntMax = 3; @@ -1241,7 +1264,7 @@ static void UartReset() { Uart.posCnt = 0; memset(Uart.output, 0x00, 3); } - +*/ // static void UartInit(uint8_t *data) { // Uart.output = data; // UartReset(); @@ -1253,7 +1276,7 @@ static void UartReset() { // tag's response, which we leave in the buffer to be demodulated on the // PC side. //============================================================================= - +/* static struct { enum { DEMOD_UNSYNCD, @@ -1272,7 +1295,7 @@ static struct { int sumI; int sumQ; } Demod; - +*/ /* * Handles reception of a bit from the tag * @@ -1287,32 +1310,8 @@ static struct { * false if we are still waiting for some more * */ - - #ifndef SUBCARRIER_DETECT_THRESHOLD - # define SUBCARRIER_DETECT_THRESHOLD 8 - #endif - // Subcarrier amplitude v = sqrt(ci^2 + cq^2), approximated here by max(abs(ci),abs(cq)) + 1/2*min(abs(ci),abs(cq))) -#ifndef CHECK_FOR_SUBCARRIER -# define CHECK_FOR_SUBCARRIER() { v = MAX(ai, aq) + MIN(halfci, halfcq); } -#endif - -// The soft decision on the bit uses an estimate of just the -// quadrant of the reference angle, not the exact angle. -// Subcarrier amplitude v = sqrt(ci^2 + cq^2), approximated here by max(abs(ci),abs(cq)) + 1/2*min(abs(ci),abs(cq))) -#define MAKE_SOFT_DECISION() { \ - if(Demod.sumI > 0) \ - v = ci; \ - else \ - v = -ci; \ - \ - if(Demod.sumQ > 0) \ - v += cq; \ - else \ - v -= cq; \ - \ - } - +/* static RAMFUNC int HandleLegicSamplesDemod(int ci, int cq) { int v = 0; @@ -1467,7 +1466,8 @@ static RAMFUNC int HandleLegicSamplesDemod(int ci, int cq) } return FALSE; } - +*/ +/* // Clear out the state of the "UART" that receives from the tag. static void DemodReset() { Demod.len = 0; @@ -1485,13 +1485,17 @@ static void DemodInit(uint8_t *data) { Demod.output = data; DemodReset(); } +*/ /* * Demodulate the samples we received from the tag, also log to tracebuffer * quiet: set to 'TRUE' to disable debug output */ + + /* #define LEGIC_DMA_BUFFER_SIZE 256 -static void GetSamplesForLegicDemod(int n, bool quiet) + + static void GetSamplesForLegicDemod(int n, bool quiet) { int max = 0; bool gotFrame = FALSE; @@ -1566,9 +1570,13 @@ static void GetSamplesForLegicDemod(int n, bool quiet) LogTrace(Demod.output, Demod.len, 0, 0, parity, FALSE); } } + +*/ + //----------------------------------------------------------------------------- // Transmit the command (to the tag) that was placed in ToSend[]. //----------------------------------------------------------------------------- +/* static void TransmitForLegic(void) { int c; @@ -1615,12 +1623,13 @@ static void TransmitForLegic(void) } LED_B_OFF(); } - +*/ //----------------------------------------------------------------------------- // Code a layer 2 command (string of octets, including CRC) into ToSend[], // so that it is ready to transmit to the tag using TransmitForLegic(). //----------------------------------------------------------------------------- +/* static void CodeLegicBitsAsReader(const uint8_t *cmd, uint8_t cmdlen, int bits) { int i, j; @@ -1652,11 +1661,12 @@ static void CodeLegicBitsAsReader(const uint8_t *cmd, uint8_t cmdlen, int bits) // Convert from last character reference to length ++ToSendMax; } - +*/ /** Convenience function to encode, transmit and trace Legic comms **/ -static void CodeAndTransmitLegicAsReader(const uint8_t *cmd, uint8_t cmdlen, int bits) +/* + static void CodeAndTransmitLegicAsReader(const uint8_t *cmd, uint8_t cmdlen, int bits) { CodeLegicBitsAsReader(cmd, cmdlen, bits); TransmitForLegic(); @@ -1666,58 +1676,9 @@ static void CodeAndTransmitLegicAsReader(const uint8_t *cmd, uint8_t cmdlen, int } } -int ice_legic_select_card() -{ - //int cmd_size=0, card_size=0; - uint8_t wakeup[] = { 0x7F }; - uint8_t getid[] = {0x19}; - - //legic_prng_init(SESSION_IV); - - // first, wake up the tag, 7bits - CodeAndTransmitLegicAsReader(wakeup, sizeof(wakeup), 7); - - GetSamplesForLegicDemod(1000, TRUE); - - //frame_receiveAsReader(¤t_frame, 6, 1); - - legic_prng_forward(1); /* we wait anyways */ - - //while(timer->TC_CV < 387) ; /* ~ 258us */ - //frame_sendAsReader(0x19, 6); - CodeAndTransmitLegicAsReader(getid, sizeof(getid), 8); - GetSamplesForLegicDemod(1000, TRUE); - - //if (Demod.len < 14) return 2; - Dbprintf("CARD TYPE: %02x LEN: %d", Demod.output[0], Demod.len); - - switch(Demod.output[0]) { - case 0x1d: - DbpString("MIM 256 card found"); - // cmd_size = 9; - // card_size = 256; - break; - case 0x3d: - DbpString("MIM 1024 card found"); - // cmd_size = 11; - // card_size = 1024; - break; - default: - return -1; - } - - // if(bytes == -1) - // bytes = card_size; - - // if(bytes + offset >= card_size) - // bytes = card_size - offset; - - FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); - set_tracing(FALSE); - return 1; -} - +*/ // Set up LEGIC communication +/* void ice_legic_setup() { // standard things. @@ -1746,4 +1707,5 @@ void ice_legic_setup() { // initalize prng legic_prng_init(0); -} \ No newline at end of file +} +*/ \ No newline at end of file