mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2024-09-20 15:26:13 +08:00
Merge pull request #1621 from lnv42/iso15sniff2sc
Improve iso15 sniffing: add support for dual subcarriers sniffing
This commit is contained in:
commit
d4fece64ec
|
@ -103,7 +103,7 @@ endif
|
|||
include Standalone/Makefile.inc
|
||||
|
||||
#the FPGA bitstream files. Note: order matters!
|
||||
FPGA_BITSTREAMS = fpga_lf.bit fpga_hf.bit fpga_felica.bit
|
||||
FPGA_BITSTREAMS = fpga_lf.bit fpga_hf.bit fpga_felica.bit fpga_hf_15.bit
|
||||
|
||||
#the lz4 source files required for decompressing the fpga config at run time
|
||||
SRC_LZ4 = lz4.c
|
||||
|
|
|
@ -102,7 +102,7 @@ void RunMod(void) {
|
|||
rdv40_spiffs_lazy_mount();
|
||||
#endif
|
||||
|
||||
SniffIso15693(0, NULL);
|
||||
SniffIso15693(0, NULL, false);
|
||||
|
||||
Dbprintf("Stopped sniffing");
|
||||
SpinDelay(200);
|
||||
|
|
|
@ -1232,7 +1232,7 @@ static void PacketReceived(PacketCommandNG *packet) {
|
|||
break;
|
||||
}
|
||||
case CMD_HF_ISO15693_SNIFF: {
|
||||
SniffIso15693(0, NULL);
|
||||
SniffIso15693(0, NULL, false);
|
||||
reply_ng(CMD_HF_ISO15693_SNIFF, PM3_SUCCESS, NULL, 0);
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -162,7 +162,9 @@ void FpgaSetupSsc(uint16_t fpga_mode) {
|
|||
|
||||
// 8, 16 or 32 bits per transfer, no loopback, MSB first, 1 transfer per sync
|
||||
// pulse, no output sync
|
||||
if ((fpga_mode & FPGA_MAJOR_MODE_MASK) == FPGA_MAJOR_MODE_HF_READER && FpgaGetCurrent() == FPGA_BITSTREAM_HF) {
|
||||
if (((fpga_mode & FPGA_MAJOR_MODE_MASK) == FPGA_MAJOR_MODE_HF_READER ||
|
||||
(fpga_mode & FPGA_MAJOR_MODE_MASK) == FPGA_MAJOR_MODE_HF_FSK_READER) &&
|
||||
(FpgaGetCurrent() == FPGA_BITSTREAM_HF || FpgaGetCurrent() == FPGA_BITSTREAM_HF_15)) {
|
||||
AT91C_BASE_SSC->SSC_RFMR = SSC_FRAME_MODE_BITS_IN_WORD(16) | AT91C_SSC_MSBF | SSC_FRAME_MODE_WORDS_PER_TRANSFER(0);
|
||||
} else {
|
||||
AT91C_BASE_SSC->SSC_RFMR = SSC_FRAME_MODE_BITS_IN_WORD(8) | AT91C_SSC_MSBF | SSC_FRAME_MODE_WORDS_PER_TRANSFER(0);
|
||||
|
@ -612,7 +614,7 @@ void switch_off(void) {
|
|||
Dbprintf("switch_off");
|
||||
}
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
|
||||
if (downloaded_bitstream == FPGA_BITSTREAM_HF) {
|
||||
if (downloaded_bitstream == FPGA_BITSTREAM_HF || downloaded_bitstream == FPGA_BITSTREAM_HF_15) {
|
||||
FpgaDisableSscDma();
|
||||
}
|
||||
set_tracing(false);
|
||||
|
|
|
@ -29,6 +29,7 @@
|
|||
#define FPGA_BITSTREAM_LF 1
|
||||
#define FPGA_BITSTREAM_HF 2
|
||||
#define FPGA_BITSTREAM_HF_FELICA 3
|
||||
#define FPGA_BITSTREAM_HF_15 4
|
||||
|
||||
/*
|
||||
Communication between ARM / FPGA is done inside armsrc/fpgaloader.c (function FpgaSendCommand)
|
||||
|
@ -77,6 +78,7 @@ thres| x x x x x x x x
|
|||
#define FPGA_MAJOR_MODE_HF_SNIFF (3<<6) // D
|
||||
#define FPGA_MAJOR_MODE_HF_ISO18092 (4<<6) // D
|
||||
#define FPGA_MAJOR_MODE_HF_GET_TRACE (5<<6) // D
|
||||
#define FPGA_MAJOR_MODE_HF_FSK_READER (6<<6) // D
|
||||
|
||||
// BOTH HF / LF
|
||||
#define FPGA_MAJOR_MODE_OFF (7<<6) // D
|
||||
|
@ -104,6 +106,7 @@ thres| x x x x x x x x
|
|||
#define FPGA_HF_READER_SUBCARRIER_848_KHZ (0<<4)
|
||||
#define FPGA_HF_READER_SUBCARRIER_424_KHZ (1<<4)
|
||||
#define FPGA_HF_READER_SUBCARRIER_212_KHZ (2<<4)
|
||||
#define FPGA_HF_READER_2SUBCARRIERS_424_484_KHZ (3<<4)
|
||||
|
||||
// Options for the HF simulated tag, how to modulate
|
||||
#define FPGA_HF_SIMULATOR_NO_MODULATION 0x0 // 0000
|
||||
|
|
|
@ -91,7 +91,7 @@ static uint8_t get_pagemap(const picopass_hdr_t *hdr) {
|
|||
// Both sides of communication!
|
||||
//=============================================================================
|
||||
void SniffIClass(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
||||
SniffIso15693(jam_search_len, jam_search_string);
|
||||
SniffIso15693(jam_search_len, jam_search_string, true);
|
||||
}
|
||||
|
||||
static void rotateCSN(const uint8_t *original_csn, uint8_t *rotated_csn) {
|
||||
|
|
|
@ -54,7 +54,7 @@
|
|||
// *) signal decoding is unable to detect collisions.
|
||||
// *) add anti-collision support for inventory-commands
|
||||
// *) read security status of a block
|
||||
// *) sniffing and simulation do not support two subcarrier modes.
|
||||
// *) simulation do not support two subcarrier modes.
|
||||
// *) remove or refactor code under "deprecated"
|
||||
// *) document all the functions
|
||||
|
||||
|
@ -1204,7 +1204,7 @@ void AcquireRawAdcSamplesIso15693(void) {
|
|||
|
||||
LEDsoff();
|
||||
DbpString("Starting to acquire data...");
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF_15);
|
||||
|
||||
BigBuf_free();
|
||||
clear_trace();
|
||||
|
@ -1259,12 +1259,329 @@ void AcquireRawAdcSamplesIso15693(void) {
|
|||
LEDsoff();
|
||||
}
|
||||
|
||||
void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
||||
//=============================================================================
|
||||
// An ISO 15693 decoder for tag responses in FSK (two subcarriers) mode.
|
||||
// Subcarriers frequencies are 424kHz and 484kHz (fc/32 and fc/28),
|
||||
// LED handling:
|
||||
// LED C -> ON once we have received the SOF and are expecting the rest.
|
||||
// LED C -> OFF once we have received EOF or are unsynced
|
||||
//
|
||||
// Returns: true if we received a EOF
|
||||
// false if we are still waiting for some more
|
||||
//=============================================================================
|
||||
//#define DEBUG 1
|
||||
#define FREQ_IS_484(f) ((f & 1) == 1) //(f >= 26 && f <= 30)
|
||||
#define FREQ_IS_424(f) ((f & 2) == 2) //(f >= 30 && f <= 34)
|
||||
#define FREQ_IS_0(f) ((f & 3) == 0) // (f <= 24 || f >= 36)
|
||||
#define SEOF_COUNT(c, s) ((s) ? (c >= 11 && c <= 13) : (c >= 44 && c <= 52))
|
||||
#define LOGIC_COUNT(c, s) ((s) ? (c >= 3 && c <= 6) : (c >= 13 && c <= 21))
|
||||
#define MAX_COUNT(c, s) ((s) ? (c >= 13) : (c >= 52))
|
||||
#define MIN_COUNT(c, s) ((s) ? (c <= 2) : (c <= 4))
|
||||
|
||||
typedef struct DecodeTagFSK {
|
||||
enum {
|
||||
STATE_FSK_ERROR,
|
||||
STATE_FSK_BEFORE_SOF,
|
||||
STATE_FSK_SOF_484,
|
||||
STATE_FSK_SOF_424,
|
||||
STATE_FSK_SOF_END_484,
|
||||
STATE_FSK_SOF_END_424,
|
||||
STATE_FSK_RECEIVING_DATA_484,
|
||||
STATE_FSK_RECEIVING_DATA_424,
|
||||
STATE_FSK_EOF
|
||||
} state;
|
||||
enum {
|
||||
LOGIC0_PART1,
|
||||
LOGIC1_PART1,
|
||||
LOGIC0_PART2,
|
||||
LOGIC1_PART2,
|
||||
SOF
|
||||
} lastBit;
|
||||
uint8_t count;
|
||||
uint8_t bitCount;
|
||||
uint8_t shiftReg;
|
||||
uint16_t len;
|
||||
uint16_t max_len;
|
||||
uint8_t *output;
|
||||
} DecodeTagFSK_t;
|
||||
|
||||
static void DecodeTagFSKReset(DecodeTagFSK_t *DecodeTag) {
|
||||
DecodeTag->state = STATE_FSK_BEFORE_SOF;
|
||||
DecodeTag->bitCount = 0;
|
||||
DecodeTag->len = 0;
|
||||
DecodeTag->shiftReg = 0;
|
||||
}
|
||||
|
||||
static void DecodeTagFSKInit(DecodeTagFSK_t *DecodeTag, uint8_t *data, uint16_t max_len) {
|
||||
DecodeTag->output = data;
|
||||
DecodeTag->max_len = max_len;
|
||||
DecodeTagFSKReset(DecodeTag);
|
||||
}
|
||||
|
||||
// Performances of this function are crutial for stability
|
||||
// as it is called in real time for every samples
|
||||
static int RAMFUNC Handle15693FSKSamplesFromTag(uint8_t freq, DecodeTagFSK_t *DecodeTag, bool recv_speed)
|
||||
{
|
||||
switch(DecodeTag->state) {
|
||||
case STATE_FSK_BEFORE_SOF:
|
||||
if (FREQ_IS_484(freq))
|
||||
{ // possible SOF starting
|
||||
DecodeTag->state = STATE_FSK_SOF_484;
|
||||
DecodeTag->lastBit = LOGIC0_PART1;
|
||||
DecodeTag->count = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case STATE_FSK_SOF_484:
|
||||
//DbpString("STATE_FSK_SOF_484");
|
||||
if (FREQ_IS_424(freq) && SEOF_COUNT(DecodeTag->count, recv_speed))
|
||||
{ // SOF part1 continue at 424
|
||||
DecodeTag->state = STATE_FSK_SOF_424;
|
||||
DecodeTag->count = 1;
|
||||
}
|
||||
else if (FREQ_IS_484(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still in SOF at 484
|
||||
{
|
||||
DecodeTag->count++;
|
||||
}
|
||||
else // SOF failed, roll back
|
||||
{
|
||||
DecodeTag->state = STATE_FSK_BEFORE_SOF;
|
||||
}
|
||||
break;
|
||||
|
||||
case STATE_FSK_SOF_424:
|
||||
//DbpString("STATE_FSK_SOF_424");
|
||||
if (FREQ_IS_484(freq) && SEOF_COUNT(DecodeTag->count, recv_speed))
|
||||
{ // SOF part 1 finished
|
||||
DecodeTag->state = STATE_FSK_SOF_END_484;
|
||||
DecodeTag->count = 1;
|
||||
}
|
||||
else if (FREQ_IS_424(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still in SOF at 424
|
||||
DecodeTag->count++;
|
||||
else // SOF failed, roll back
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("SOF_424 failed: freq=%d, count=%d, recv_speed=%d", freq, DecodeTag->count, recv_speed);
|
||||
#endif
|
||||
DecodeTag->state = STATE_FSK_BEFORE_SOF;
|
||||
}
|
||||
break;
|
||||
|
||||
case STATE_FSK_SOF_END_484:
|
||||
if (FREQ_IS_424(freq) && LOGIC_COUNT(DecodeTag->count, recv_speed))
|
||||
{
|
||||
DecodeTag->state = STATE_FSK_SOF_END_424;
|
||||
DecodeTag->count = 1;
|
||||
}
|
||||
else if (FREQ_IS_484(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still in SOF_END_484
|
||||
DecodeTag->count++;
|
||||
else // SOF failed, roll back
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("SOF_END_484 failed: freq=%d, count=%d, recv_speed=%d", freq, DecodeTag->count, recv_speed);
|
||||
#endif
|
||||
DecodeTag->state = STATE_FSK_BEFORE_SOF;
|
||||
}
|
||||
break;
|
||||
case STATE_FSK_SOF_END_424:
|
||||
if (FREQ_IS_484(freq) && LOGIC_COUNT(DecodeTag->count, recv_speed))
|
||||
{ // SOF finished at 484
|
||||
DecodeTag->count = 1;
|
||||
DecodeTag->lastBit = SOF;
|
||||
DecodeTag->state = STATE_FSK_RECEIVING_DATA_484;
|
||||
LED_C_ON();
|
||||
}
|
||||
else if (FREQ_IS_424(freq) && LOGIC_COUNT(DecodeTag->count-2, recv_speed))
|
||||
{ // SOF finished at 424 (wait count+2 to be sure that next freq is 424)
|
||||
DecodeTag->count = 2;
|
||||
DecodeTag->lastBit = SOF;
|
||||
DecodeTag->state = STATE_FSK_RECEIVING_DATA_424;
|
||||
LED_C_ON();
|
||||
}
|
||||
else if (FREQ_IS_424(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still in SOF_END_424
|
||||
DecodeTag->count++;
|
||||
else // SOF failed, roll back
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("SOF_END_424 failed: freq=%d, count=%d, recv_speed=%d", freq, DecodeTag->count, recv_speed);
|
||||
#endif
|
||||
DecodeTag->state = STATE_FSK_BEFORE_SOF;
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case STATE_FSK_RECEIVING_DATA_424:
|
||||
if (FREQ_IS_484(freq) && LOGIC_COUNT(DecodeTag->count, recv_speed))
|
||||
{
|
||||
if (DecodeTag->lastBit == LOGIC1_PART1)
|
||||
{ // logic 1 finished, goto 484
|
||||
DecodeTag->lastBit = LOGIC1_PART2;
|
||||
|
||||
DecodeTag->shiftReg >>= 1;
|
||||
DecodeTag->shiftReg |= 0x80;
|
||||
DecodeTag->bitCount++;
|
||||
if (DecodeTag->bitCount == 8) {
|
||||
DecodeTag->output[DecodeTag->len++] = DecodeTag->shiftReg;
|
||||
if (DecodeTag->len > DecodeTag->max_len) {
|
||||
// buffer overflow, give up
|
||||
LED_C_OFF();
|
||||
return true;
|
||||
}
|
||||
DecodeTag->bitCount = 0;
|
||||
DecodeTag->shiftReg = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{ // end of LOGIC0_PART1
|
||||
DecodeTag->lastBit = LOGIC0_PART1;
|
||||
}
|
||||
DecodeTag->count = 1;
|
||||
DecodeTag->state = STATE_FSK_RECEIVING_DATA_484;
|
||||
}
|
||||
else if (FREQ_IS_424(freq) && LOGIC_COUNT(DecodeTag->count-2, recv_speed) &&
|
||||
DecodeTag->lastBit == LOGIC1_PART1)
|
||||
{ // logic 1 finished, stay in 484
|
||||
DecodeTag->lastBit = LOGIC1_PART2;
|
||||
|
||||
DecodeTag->shiftReg >>= 1;
|
||||
DecodeTag->shiftReg |= 0x80;
|
||||
DecodeTag->bitCount++;
|
||||
if (DecodeTag->bitCount == 8) {
|
||||
DecodeTag->output[DecodeTag->len++] = DecodeTag->shiftReg;
|
||||
if (DecodeTag->len > DecodeTag->max_len) {
|
||||
// buffer overflow, give up
|
||||
LED_C_OFF();
|
||||
return true;
|
||||
}
|
||||
DecodeTag->bitCount = 0;
|
||||
DecodeTag->shiftReg = 0;
|
||||
}
|
||||
DecodeTag->count = 2;
|
||||
}
|
||||
else if (FREQ_IS_424(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still at 424
|
||||
DecodeTag->count++;
|
||||
|
||||
else if (FREQ_IS_484(freq) && DecodeTag->lastBit == LOGIC0_PART2 &&
|
||||
SEOF_COUNT(DecodeTag->count, recv_speed))
|
||||
{ // EOF has started
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("RECEIVING_DATA_424->EOF: freq=%d, count=%d, recv_speed=%d, lastbit=%d, state=%d", freq, DecodeTag->count, recv_speed, DecodeTag->lastBit, DecodeTag->state);
|
||||
#endif
|
||||
DecodeTag->count = 1;
|
||||
DecodeTag->state = STATE_FSK_EOF;
|
||||
LED_C_OFF();
|
||||
}
|
||||
else // error
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("RECEIVING_DATA_424 error: freq=%d, count=%d, recv_speed=%d, lastbit=%d, state=%d", freq, DecodeTag->count, recv_speed, DecodeTag->lastBit, DecodeTag->state);
|
||||
#endif
|
||||
DecodeTag->state = STATE_FSK_ERROR;
|
||||
LED_C_OFF();
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
|
||||
case STATE_FSK_RECEIVING_DATA_484:
|
||||
if (FREQ_IS_424(freq) && LOGIC_COUNT(DecodeTag->count, recv_speed))
|
||||
{
|
||||
if (DecodeTag->lastBit == LOGIC0_PART1)
|
||||
{ // logic 0 finished, goto 424
|
||||
DecodeTag->lastBit = LOGIC0_PART2;
|
||||
|
||||
DecodeTag->shiftReg >>= 1;
|
||||
DecodeTag->bitCount++;
|
||||
if (DecodeTag->bitCount == 8) {
|
||||
DecodeTag->output[DecodeTag->len++] = DecodeTag->shiftReg;
|
||||
if (DecodeTag->len > DecodeTag->max_len) {
|
||||
// buffer overflow, give up
|
||||
LED_C_OFF();
|
||||
return true;
|
||||
}
|
||||
DecodeTag->bitCount = 0;
|
||||
DecodeTag->shiftReg = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{ // end of LOGIC1_PART1
|
||||
DecodeTag->lastBit = LOGIC1_PART1;
|
||||
}
|
||||
DecodeTag->count = 1;
|
||||
DecodeTag->state = STATE_FSK_RECEIVING_DATA_424;
|
||||
}
|
||||
else if (FREQ_IS_484(freq) && LOGIC_COUNT(DecodeTag->count-2, recv_speed) &&
|
||||
DecodeTag->lastBit == LOGIC0_PART1)
|
||||
{ // logic 0 finished, stay in 424
|
||||
DecodeTag->lastBit = LOGIC0_PART2;
|
||||
|
||||
DecodeTag->shiftReg >>= 1;
|
||||
DecodeTag->bitCount++;
|
||||
if (DecodeTag->bitCount == 8) {
|
||||
DecodeTag->output[DecodeTag->len++] = DecodeTag->shiftReg;
|
||||
if (DecodeTag->len > DecodeTag->max_len) {
|
||||
// buffer overflow, give up
|
||||
LED_C_OFF();
|
||||
return true;
|
||||
}
|
||||
DecodeTag->bitCount = 0;
|
||||
DecodeTag->shiftReg = 0;
|
||||
}
|
||||
DecodeTag->count = 2;
|
||||
}
|
||||
else if (FREQ_IS_484(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still at 484
|
||||
DecodeTag->count++;
|
||||
else // error
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("RECEIVING_DATA_484 error: freq=%d, count=%d, recv_speed=%d, lastbit=%d, state=%d", freq, DecodeTag->count, recv_speed, DecodeTag->lastBit, DecodeTag->state);
|
||||
#endif
|
||||
LED_C_OFF();
|
||||
DecodeTag->state = STATE_FSK_ERROR;
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
|
||||
case STATE_FSK_EOF:
|
||||
if (FREQ_IS_484(freq) && !MAX_COUNT(DecodeTag->count, recv_speed)) // still at 484
|
||||
{
|
||||
DecodeTag->count++;
|
||||
if (SEOF_COUNT(DecodeTag->count, recv_speed))
|
||||
return true; // end of the transmission
|
||||
}
|
||||
else // error
|
||||
{
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("EOF error: freq=%d, count=%d, recv_speed=%d", freq, DecodeTag->count, recv_speed);
|
||||
#endif
|
||||
DecodeTag->state = STATE_FSK_ERROR;
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case STATE_FSK_ERROR:
|
||||
LED_C_OFF();
|
||||
#ifdef DEBUG
|
||||
if (DEBUG)
|
||||
Dbprintf("FSK error: freq=%d, count=%d, recv_speed=%d", freq, DecodeTag->count, recv_speed);
|
||||
#endif
|
||||
return true; // error
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string, bool iclass) {
|
||||
|
||||
LEDsoff();
|
||||
LED_A_ON();
|
||||
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF_15);
|
||||
|
||||
DbpString("Starting to sniff. Press PM3 Button to stop.");
|
||||
|
||||
|
@ -1276,11 +1593,16 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
uint8_t response[ISO15693_MAX_RESPONSE_LENGTH] = {0};
|
||||
DecodeTagInit(&dtag, response, sizeof(response));
|
||||
|
||||
DecodeTagFSK_t dtagfsk = {0};
|
||||
uint8_t response2[ISO15693_MAX_RESPONSE_LENGTH] = {0};
|
||||
DecodeTagFSKInit(&dtagfsk, response2, sizeof(response2));
|
||||
|
||||
DecodeReader_t dreader = {0};
|
||||
uint8_t cmd[ISO15693_MAX_COMMAND_LENGTH] = {0};
|
||||
DecodeReaderInit(&dreader, cmd, sizeof(cmd), jam_search_len, jam_search_string);
|
||||
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_MODE_SNIFF_AMPLITUDE);
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_MODE_SNIFF_AMPLITUDE | FPGA_HF_READER_2SUBCARRIERS_424_484_KHZ);
|
||||
|
||||
LED_D_OFF();
|
||||
|
||||
SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
|
||||
|
@ -1301,6 +1623,8 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
bool tag_is_active = false;
|
||||
bool reader_is_active = false;
|
||||
bool expect_tag_answer = false;
|
||||
bool expect_fsk_answer = false;
|
||||
bool expect_fast_answer = true; // default to true is required for iClass
|
||||
int dma_start_time = 0;
|
||||
|
||||
// Count of samples received so far, so that we can include timing
|
||||
|
@ -1319,7 +1643,9 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
dma_start_time = GetCountSspClk() & 0xfffffff0;
|
||||
}
|
||||
|
||||
volatile uint16_t sniffdata = *upTo++;
|
||||
volatile uint16_t sniffdata;
|
||||
volatile uint16_t sniffdata_prev = sniffdata;
|
||||
sniffdata = *upTo++;
|
||||
|
||||
// we have read all of the DMA buffer content
|
||||
if (upTo >= dma->buf + DMA_BUFFER_SIZE) {
|
||||
|
@ -1350,7 +1676,7 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
}
|
||||
|
||||
// no need to try decoding reader data if the tag is sending
|
||||
if (tag_is_active == false) {
|
||||
if (!tag_is_active) {
|
||||
|
||||
if (Handle15693SampleFromReader((sniffdata & 0x02) >> 1, &dreader)) {
|
||||
|
||||
|
@ -1361,13 +1687,19 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
- 32 * 16 // time for SOF transfer
|
||||
- 16 * 16; // time for EOF transfer
|
||||
LogTrace_ISO15693(dreader.output, dreader.byteCount, (sof_time * 4), (eof_time * 4), NULL, true);
|
||||
|
||||
if (!iclass) // Those flags don't exist in iClass
|
||||
{
|
||||
expect_fsk_answer = dreader.output[0] & ISO15_REQ_SUBCARRIER_TWO;
|
||||
expect_fast_answer = dreader.output[0] & ISO15_REQ_DATARATE_HIGH;
|
||||
}
|
||||
}
|
||||
// And ready to receive another command.
|
||||
DecodeReaderReset(&dreader);
|
||||
//DecodeReaderReset(&dreader); // already reseted
|
||||
DecodeTagReset(&dtag);
|
||||
DecodeTagFSKReset(&dtagfsk);
|
||||
reader_is_active = false;
|
||||
expect_tag_answer = true;
|
||||
|
||||
} else if (Handle15693SampleFromReader(sniffdata & 0x01, &dreader)) {
|
||||
|
||||
uint32_t eof_time = dma_start_time + (samples * 16) + 16 - DELAY_READER_TO_ARM_SNIFF; // end of EOF
|
||||
|
@ -1377,39 +1709,81 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
- 32 * 16 // time for SOF transfer
|
||||
- 16 * 16; // time for EOF transfer
|
||||
LogTrace_ISO15693(dreader.output, dreader.byteCount, (sof_time * 4), (eof_time * 4), NULL, true);
|
||||
if (!iclass) // Those flags don't exist in iClass
|
||||
{
|
||||
expect_fsk_answer = dreader.output[0] & ISO15_REQ_SUBCARRIER_TWO;
|
||||
expect_fast_answer = dreader.output[0] & ISO15_REQ_DATARATE_HIGH;
|
||||
}
|
||||
}
|
||||
// And ready to receive another command
|
||||
DecodeReaderReset(&dreader);
|
||||
//DecodeReaderReset(&dreader); // already reseted
|
||||
DecodeTagReset(&dtag);
|
||||
DecodeTagFSKReset(&dtagfsk);
|
||||
reader_is_active = false;
|
||||
expect_tag_answer = true;
|
||||
|
||||
} else {
|
||||
reader_is_active = (dreader.state >= STATE_READER_RECEIVE_DATA_1_OUT_OF_4);
|
||||
}
|
||||
}
|
||||
|
||||
if (reader_is_active == false && expect_tag_answer) { // no need to try decoding tag data if the reader is currently sending or no answer expected yet
|
||||
if (!reader_is_active && expect_tag_answer) { // no need to try decoding tag data if the reader is currently sending or no answer expected yet
|
||||
|
||||
if (Handle15693SamplesFromTag(sniffdata >> 2, &dtag)) {
|
||||
if (!expect_fsk_answer)
|
||||
{
|
||||
if (Handle15693SamplesFromTag((sniffdata >> 4) << 2, &dtag)) {
|
||||
|
||||
uint32_t eof_time = dma_start_time + (samples * 16) - DELAY_TAG_TO_ARM_SNIFF; // end of EOF
|
||||
if (dtag.lastBit == SOF_PART2) {
|
||||
eof_time -= (8 * 16); // needed 8 additional samples to confirm single SOF (iCLASS)
|
||||
uint32_t eof_time = dma_start_time + (samples * 16) - DELAY_TAG_TO_ARM_SNIFF; // end of EOF
|
||||
if (dtag.lastBit == SOF_PART2) {
|
||||
eof_time -= (8 * 16); // needed 8 additional samples to confirm single SOF (iCLASS)
|
||||
}
|
||||
uint32_t sof_time = eof_time
|
||||
- dtag.len * 8 * 8 * 16 // time for byte transfers
|
||||
- (32 * 16) // time for SOF transfer
|
||||
- (dtag.lastBit != SOF_PART2 ? (32 * 16) : 0); // time for EOF transfer
|
||||
|
||||
LogTrace_ISO15693(dtag.output, dtag.len, (sof_time * 4), (eof_time * 4), NULL, false);
|
||||
// And ready to receive another response.
|
||||
DecodeTagReset(&dtag);
|
||||
DecodeTagFSKReset(&dtagfsk);
|
||||
DecodeReaderReset(&dreader);
|
||||
expect_tag_answer = false;
|
||||
tag_is_active = false;
|
||||
} else {
|
||||
tag_is_active = (dtag.state >= STATE_TAG_RECEIVING_DATA);
|
||||
}
|
||||
uint32_t sof_time = eof_time
|
||||
- dtag.len * 8 * 8 * 16 // time for byte transfers
|
||||
- (32 * 16) // time for SOF transfer
|
||||
- (dtag.lastBit != SOF_PART2 ? (32 * 16) : 0); // time for EOF transfer
|
||||
}
|
||||
else
|
||||
{
|
||||
if (FREQ_IS_0((sniffdata >> 2) & 0x3)) // tolerate 1 00
|
||||
sniffdata = sniffdata_prev;
|
||||
|
||||
LogTrace_ISO15693(dtag.output, dtag.len, (sof_time * 4), (eof_time * 4), NULL, false);
|
||||
// And ready to receive another response.
|
||||
DecodeTagReset(&dtag);
|
||||
DecodeReaderReset(&dreader);
|
||||
expect_tag_answer = false;
|
||||
tag_is_active = false;
|
||||
} else {
|
||||
tag_is_active = (dtag.state >= STATE_TAG_RECEIVING_DATA);
|
||||
if (Handle15693FSKSamplesFromTag((sniffdata >> 2) & 0x3, &dtagfsk, expect_fast_answer)) {
|
||||
expect_fsk_answer = false;
|
||||
}
|
||||
else {
|
||||
tag_is_active = (dtagfsk.state >= STATE_FSK_RECEIVING_DATA_484);
|
||||
}
|
||||
if (!expect_fsk_answer)
|
||||
{ // FSK answer no more expected: switch back to ASK
|
||||
if (dtagfsk.len > 0)
|
||||
{
|
||||
uint32_t eof_time = dma_start_time + (samples * 16) - DELAY_TAG_TO_ARM_SNIFF; // end of EOF
|
||||
if (dtagfsk.lastBit == SOF) {
|
||||
eof_time -= (8 * 16); // needed 8 additional samples to confirm single SOF (iCLASS)
|
||||
}
|
||||
uint32_t sof_time = eof_time
|
||||
- dtagfsk.len * 8 * 8 * 16 // time for byte transfers
|
||||
- (32 * 16) // time for SOF transfer
|
||||
- (dtagfsk.lastBit != SOF ? (32 * 16) : 0); // time for EOF transfer
|
||||
|
||||
LogTrace_ISO15693(dtagfsk.output, dtagfsk.len, (sof_time * 4), (eof_time * 4), NULL, false);
|
||||
}
|
||||
|
||||
DecodeTagFSKReset(&dtagfsk);
|
||||
DecodeReaderReset(&dreader);
|
||||
expect_tag_answer = false;
|
||||
tag_is_active = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1424,6 +1798,9 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
Dbprintf(" DecodeTag State........%d", dtag.state);
|
||||
Dbprintf(" DecodeTag byteCnt......%d", dtag.len);
|
||||
Dbprintf(" DecodeTag posCount.....%d", dtag.posCount);
|
||||
Dbprintf(" DecodeTagFSK State.....%d", dtagfsk.state);
|
||||
Dbprintf(" DecodeTagFSK byteCnt...%d", dtagfsk.len);
|
||||
Dbprintf(" DecodeTagFSK count.....%d", dtagfsk.count);
|
||||
Dbprintf(" DecodeReader State.....%d", dreader.state);
|
||||
Dbprintf(" DecodeReader byteCnt...%d", dreader.byteCount);
|
||||
Dbprintf(" DecodeReader posCount..%d", dreader.posCount);
|
||||
|
@ -1436,7 +1813,7 @@ void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string) {
|
|||
void Iso15693InitReader(void) {
|
||||
|
||||
LEDsoff();
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF_15);
|
||||
|
||||
// Start from off (no field generated)
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
|
||||
|
@ -1679,7 +2056,7 @@ void ReaderIso15693(uint32_t parameter, iso15_card_select_t *p_card) {
|
|||
// When SIM: initialize the Proxmark3 as ISO15693 tag
|
||||
void Iso15693InitTag(void) {
|
||||
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF_15);
|
||||
|
||||
// Start from off (no field generated)
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
|
||||
|
|
|
@ -50,7 +50,7 @@ void SimTagIso15693(uint8_t *uid); // simulate an ISO15693 tag - greg
|
|||
void BruteforceIso15693Afi(uint32_t speed); // find an AFI of a tag - atrox
|
||||
void DirectTag15693Command(uint32_t datalen, uint32_t speed, uint32_t recv, uint8_t *data); // send arbitrary commands from CLI - atrox
|
||||
|
||||
void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string);
|
||||
void SniffIso15693(uint8_t jam_search_len, uint8_t *jam_search_string, bool iclass);
|
||||
|
||||
int SendDataTag(uint8_t *send, int sendlen, bool init, bool speed_fast, uint8_t *recv,
|
||||
uint16_t max_recv_len, uint32_t start_time, uint16_t timeout, uint32_t *eof_time);
|
||||
|
|
|
@ -5,9 +5,9 @@ RMDIR = rm -rf
|
|||
# rmdir only if dir is empty, tolerate failure
|
||||
RMDIR_SOFT = -rmdir
|
||||
#
|
||||
all: fpga_lf.bit fpga_hf.bit fpga_felica.bit
|
||||
all: fpga_lf.bit fpga_hf.bit fpga_felica.bit fpga_hf_15.bit
|
||||
clean:
|
||||
$(Q)$(RM) *.bgn *.drc *.ncd *.ngd *_par.xrpt *-placed.* *-placed_pad.* *_usage.xml xst_hf.srp xst_lf.srp xst_felica.srp
|
||||
$(Q)$(RM) *.bgn *.drc *.ncd *.ngd *_par.xrpt *-placed.* *-placed_pad.* *_usage.xml xst_hf.srp xst_lf.srp xst_felica.srp xst_hf_15.srp
|
||||
$(Q)$(RM) *.map *.ngc *.xrpt *.pcf *.rbt *.bld *.mrp *.ngm *.unroutes *_summary.xml netlist.lst
|
||||
$(Q)$(RMDIR) *_auto_* xst
|
||||
|
||||
|
@ -22,6 +22,11 @@ fpga_felica.ngc: fpga_felica.v fpga.ucf xst_felica.scr util.v hi_simulate.v hi_r
|
|||
$(info [-] XST $@)
|
||||
$(Q)$(XILINX_TOOLS_PREFIX)xst -ifn xst_felica.scr
|
||||
|
||||
fpga_hf_15.ngc: fpga_hf_15.v fpga.ucf xst_hf.scr util.v hi_simulate.v hi_reader_15.v hi_iso14443a.v hi_sniffer.v hi_get_trace.v
|
||||
$(Q)$(RM) $@
|
||||
$(info [-] XST $@)
|
||||
$(Q)$(XILINX_TOOLS_PREFIX)xst -ifn xst_hf_15.scr
|
||||
|
||||
fpga_lf.ngc: fpga_lf.v fpga.ucf xst_lf.scr util.v clk_divider.v lo_edge_detect.v lo_read.v lo_passthru.v lp20khz_1MSa_iir_filter.v min_max_tracker.v lf_edge_detect.v
|
||||
$(Q)$(RM) $@
|
||||
$(info [-] XST $@)
|
||||
|
|
BIN
fpga-xc2s30/fpga_hf_15.bit
Normal file
BIN
fpga-xc2s30/fpga_hf_15.bit
Normal file
Binary file not shown.
250
fpga-xc2s30/fpga_hf_15.v
Normal file
250
fpga-xc2s30/fpga_hf_15.v
Normal file
|
@ -0,0 +1,250 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// The FPGA is responsible for interfacing between the A/D, the coil drivers,
|
||||
// and the ARM. In the low-frequency modes it passes the data straight
|
||||
// through, so that the ARM gets raw A/D samples over the SSP. In the high-
|
||||
// frequency modes, the FPGA might perform some demodulation first, to
|
||||
// reduce the amount of data that we must send to the ARM.
|
||||
//
|
||||
// I am not really an FPGA/ASIC designer, so I am sure that a lot of this
|
||||
// could be improved.
|
||||
//
|
||||
// Jonathan Westhues, March 2006
|
||||
// Added ISO14443-A support by Gerhard de Koning Gans, April 2008
|
||||
// iZsh <izsh at fail0verflow.com>, June 2014
|
||||
// Piwi, Feb 2019
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
// Defining commands, modes and options. This must be aligned to the definitions in fpgaloader.h
|
||||
// Note: the definitions here are without shifts
|
||||
|
||||
// Commands:
|
||||
`define FPGA_CMD_SET_CONFREG 1
|
||||
`define FPGA_CMD_TRACE_ENABLE 2
|
||||
|
||||
// Major modes:
|
||||
`define FPGA_MAJOR_MODE_HF_READER 0
|
||||
`define FPGA_MAJOR_MODE_HF_SIMULATOR 1
|
||||
`define FPGA_MAJOR_MODE_HF_ISO14443A 2
|
||||
`define FPGA_MAJOR_MODE_HF_SNIFF 3
|
||||
`define FPGA_MAJOR_MODE_HF_ISO18092 4
|
||||
`define FPGA_MAJOR_MODE_HF_GET_TRACE 5
|
||||
`define FPGA_MAJOR_MODE_HF_FSK_READER 6
|
||||
`define FPGA_MAJOR_MODE_OFF 7
|
||||
|
||||
// Options for the generic HF reader
|
||||
`define FPGA_HF_READER_MODE_RECEIVE_IQ 0
|
||||
`define FPGA_HF_READER_MODE_RECEIVE_AMPLITUDE 1
|
||||
`define FPGA_HF_READER_MODE_RECEIVE_PHASE 2
|
||||
`define FPGA_HF_READER_MODE_SEND_FULL_MOD 3
|
||||
`define FPGA_HF_READER_MODE_SEND_SHALLOW_MOD 4
|
||||
`define FPGA_HF_READER_MODE_SNIFF_IQ 5
|
||||
`define FPGA_HF_READER_MODE_SNIFF_AMPLITUDE 6
|
||||
`define FPGA_HF_READER_MODE_SNIFF_PHASE 7
|
||||
`define FPGA_HF_READER_MODE_SEND_JAM 8
|
||||
|
||||
`define FPGA_HF_READER_SUBCARRIER_848_KHZ 0
|
||||
`define FPGA_HF_READER_SUBCARRIER_424_KHZ 1
|
||||
`define FPGA_HF_READER_SUBCARRIER_212_KHZ 2
|
||||
`define FPGA_HF_READER_2SUBCARRIERS_424_484_KHZ 3
|
||||
|
||||
`define FPGA_HF_FSK_READER_OUTPUT_1695_KHZ 0
|
||||
`define FPGA_HF_FSK_READER_OUTPUT_848_KHZ 1
|
||||
`define FPGA_HF_FSK_READER_OUTPUT_424_KHZ 2
|
||||
`define FPGA_HF_FSK_READER_OUTPUT_212_KHZ 3
|
||||
|
||||
`define FPGA_HF_FSK_READER_NOPOWER 0
|
||||
`define FPGA_HF_FSK_READER_WITHPOWER 1
|
||||
|
||||
// Options for the HF simulated tag, how to modulate
|
||||
`define FPGA_HF_SIMULATOR_NO_MODULATION 0
|
||||
`define FPGA_HF_SIMULATOR_MODULATE_BPSK 1
|
||||
`define FPGA_HF_SIMULATOR_MODULATE_212K 2
|
||||
`define FPGA_HF_SIMULATOR_MODULATE_424K 4
|
||||
`define FPGA_HF_SIMULATOR_MODULATE_424K_8BIT 5
|
||||
|
||||
// Options for ISO14443A
|
||||
`define FPGA_HF_ISO14443A_SNIFFER 0
|
||||
`define FPGA_HF_ISO14443A_TAGSIM_LISTEN 1
|
||||
`define FPGA_HF_ISO14443A_TAGSIM_MOD 2
|
||||
`define FPGA_HF_ISO14443A_READER_LISTEN 3
|
||||
`define FPGA_HF_ISO14443A_READER_MOD 4
|
||||
|
||||
//options for ISO18092 / Felica
|
||||
`define FPGA_HF_ISO18092_FLAG_NOMOD 1 // 0001 disable modulation module
|
||||
`define FPGA_HF_ISO18092_FLAG_424K 2 // 0010 should enable 414k mode (untested). No autodetect
|
||||
`define FPGA_HF_ISO18092_FLAG_READER 4 // 0100 enables antenna power, to act as a reader instead of tag
|
||||
|
||||
`include "hi_reader_15.v"
|
||||
`include "hi_simulate.v"
|
||||
//`include "hi_iso14443a.v"
|
||||
`include "hi_sniffer.v"
|
||||
`include "util.v"
|
||||
// `include "hi_flite.v"
|
||||
`include "hi_get_trace.v"
|
||||
|
||||
module fpga_hf_15(
|
||||
input spck, output miso, input mosi, input ncs,
|
||||
input pck0, input ck_1356meg, input ck_1356megb,
|
||||
output pwr_lo, output pwr_hi,
|
||||
output pwr_oe1, output pwr_oe2, output pwr_oe3, output pwr_oe4,
|
||||
input [7:0] adc_d, output adc_clk, output adc_noe,
|
||||
output ssp_frame, output ssp_din, input ssp_dout, output ssp_clk,
|
||||
input cross_hi, input cross_lo,
|
||||
output dbg
|
||||
);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// The SPI receiver. This sets up the configuration word, which the rest of
|
||||
// the logic looks at to determine how to connect the A/D and the coil
|
||||
// drivers (i.e., which section gets it). Also assign some symbolic names
|
||||
// to the configuration bits, for use below.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
Attempt to write up how its hooked up.
|
||||
/ Iceman, 2020
|
||||
|
||||
Communication between ARM / FPGA is done inside armsrc/fpgaloader.c see: function FpgaSendCommand()
|
||||
Send 16 bit command / data pair to FPGA
|
||||
The bit format is: C3 C2 C1 C0 D11 D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0
|
||||
where
|
||||
C is 4bit command
|
||||
D is 12bit data
|
||||
|
||||
shift_reg receive this 16bit frame
|
||||
|
||||
|
||||
-----+--------- frame layout --------------------
|
||||
bit | 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
||||
-----+-------------------------------------------
|
||||
cmd | x x x x
|
||||
major| x x x
|
||||
opt | x x x x
|
||||
sub | x x
|
||||
divi | x x x x x x x x
|
||||
thres| x x x x x x x x
|
||||
-----+-------------------------------------------
|
||||
*/
|
||||
|
||||
reg [15:0] shift_reg;
|
||||
reg [8:0] conf_word;
|
||||
reg trace_enable;
|
||||
|
||||
// We switch modes between transmitting to the 13.56 MHz tag and receiving
|
||||
// from it, which means that we must make sure that we can do so without
|
||||
// glitching, or else we will glitch the transmitted carrier.
|
||||
always @(posedge ncs)
|
||||
begin
|
||||
case(shift_reg[15:12])
|
||||
`FPGA_CMD_SET_CONFREG: conf_word <= shift_reg[8:0];
|
||||
`FPGA_CMD_TRACE_ENABLE: trace_enable <= shift_reg[0];
|
||||
endcase
|
||||
end
|
||||
|
||||
always @(posedge spck)
|
||||
begin
|
||||
if(~ncs)
|
||||
begin
|
||||
shift_reg[15:1] <= shift_reg[14:0];
|
||||
shift_reg[0] <= mosi;
|
||||
end
|
||||
end
|
||||
|
||||
// select module (outputs) based on major mode
|
||||
wire [2:0] major_mode = conf_word[8:6];
|
||||
|
||||
// configuring the HF reader
|
||||
wire [1:0] subcarrier_frequency = conf_word[5:4];
|
||||
wire [3:0] minor_mode = conf_word[3:0];
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// And then we instantiate the modules corresponding to each of the FPGA's
|
||||
// major modes, and use muxes to connect the outputs of the active mode to
|
||||
// the output pins.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// 000 - HF reader
|
||||
hi_reader hr(
|
||||
ck_1356megb,
|
||||
hr_pwr_lo, hr_pwr_hi, hr_pwr_oe1, hr_pwr_oe2, hr_pwr_oe3, hr_pwr_oe4,
|
||||
adc_d, hr_adc_clk,
|
||||
hr_ssp_frame, hr_ssp_din, ssp_dout, hr_ssp_clk,
|
||||
hr_dbg,
|
||||
subcarrier_frequency, minor_mode
|
||||
);
|
||||
|
||||
// 001 - HF simulated tag
|
||||
hi_simulate hs(
|
||||
ck_1356meg,
|
||||
hs_pwr_lo, hs_pwr_hi, hs_pwr_oe1, hs_pwr_oe2, hs_pwr_oe3, hs_pwr_oe4,
|
||||
adc_d, hs_adc_clk,
|
||||
hs_ssp_frame, hs_ssp_din, ssp_dout, hs_ssp_clk,
|
||||
hs_dbg,
|
||||
minor_mode
|
||||
);
|
||||
|
||||
/*// 010 - HF ISO14443-A
|
||||
hi_iso14443a hisn(
|
||||
ck_1356meg,
|
||||
hisn_pwr_lo, hisn_pwr_hi, hisn_pwr_oe1, hisn_pwr_oe2, hisn_pwr_oe3, hisn_pwr_oe4,
|
||||
adc_d, hisn_adc_clk,
|
||||
hisn_ssp_frame, hisn_ssp_din, ssp_dout, hisn_ssp_clk,
|
||||
hisn_dbg,
|
||||
minor_mode
|
||||
);*/
|
||||
|
||||
// 011 - HF sniff
|
||||
hi_sniffer he(
|
||||
ck_1356megb,
|
||||
he_pwr_lo, he_pwr_hi, he_pwr_oe1, he_pwr_oe2, he_pwr_oe3, he_pwr_oe4,
|
||||
adc_d, he_adc_clk,
|
||||
he_ssp_frame, he_ssp_din, he_ssp_clk
|
||||
);
|
||||
|
||||
// 100 - HF ISO18092 FeliCa
|
||||
/*
|
||||
hi_flite hfl(
|
||||
ck_1356megb,
|
||||
hfl_pwr_lo, hfl_pwr_hi, hfl_pwr_oe1, hfl_pwr_oe2, hfl_pwr_oe3, hfl_pwr_oe4,
|
||||
adc_d, hfl_adc_clk,
|
||||
hfl_ssp_frame, hfl_ssp_din, ssp_dout, hfl_ssp_clk,
|
||||
hfl_dbg,
|
||||
minor_mode
|
||||
);
|
||||
*/
|
||||
|
||||
// 101 - HF get trace
|
||||
hi_get_trace gt(
|
||||
ck_1356megb,
|
||||
adc_d, trace_enable, major_mode,
|
||||
gt_ssp_frame, gt_ssp_din, gt_ssp_clk
|
||||
);
|
||||
|
||||
// Major modes:
|
||||
// 000 -- HF reader; subcarrier frequency and modulation depth selectable
|
||||
// 001 -- HF simulated tag
|
||||
// 010 -- HF ISO14443-A
|
||||
// 011 -- HF sniff
|
||||
// 100 -- HF ISO18092 FeliCa
|
||||
// 101 -- HF get trace
|
||||
// 110 -- unused
|
||||
// 111 -- FPGA_MAJOR_MODE_OFF
|
||||
|
||||
// 000 001 010 011 100 101 110 111
|
||||
mux8 mux_ssp_clk (major_mode, ssp_clk, hr_ssp_clk, hs_ssp_clk, 1'b0, he_ssp_clk, hfl_ssp_clk, gt_ssp_clk, 1'b0, 1'b0);
|
||||
mux8 mux_ssp_din (major_mode, ssp_din, hr_ssp_din, hs_ssp_din, 1'b0, he_ssp_din, hfl_ssp_din, gt_ssp_din, 1'b0, 1'b0);
|
||||
mux8 mux_ssp_frame (major_mode, ssp_frame, hr_ssp_frame, hs_ssp_frame, 1'b0, he_ssp_frame, hfl_ssp_frame, gt_ssp_frame, 1'b0, 1'b0);
|
||||
mux8 mux_pwr_oe1 (major_mode, pwr_oe1, hr_pwr_oe1, hs_pwr_oe1, 1'b0, he_pwr_oe1, hfl_pwr_oe1, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_pwr_oe2 (major_mode, pwr_oe2, hr_pwr_oe2, hs_pwr_oe2, 1'b0, he_pwr_oe2, hfl_pwr_oe2, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_pwr_oe3 (major_mode, pwr_oe3, hr_pwr_oe3, hs_pwr_oe3, 1'b0, he_pwr_oe3, hfl_pwr_oe3, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_pwr_oe4 (major_mode, pwr_oe4, hr_pwr_oe4, hs_pwr_oe4, 1'b0, he_pwr_oe4, hfl_pwr_oe4, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_pwr_lo (major_mode, pwr_lo, hr_pwr_lo, hs_pwr_lo, 1'b0, he_pwr_lo, hfl_pwr_lo, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_pwr_hi (major_mode, pwr_hi, hr_pwr_hi, hs_pwr_hi, 1'b0, he_pwr_hi, hfl_pwr_hi, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_adc_clk (major_mode, adc_clk, hr_adc_clk, hs_adc_clk, 1'b0, he_adc_clk, hfl_adc_clk, 1'b0, 1'b0, 1'b0);
|
||||
mux8 mux_dbg (major_mode, dbg, hr_dbg, hs_dbg, 1'b0, he_dbg, hfl_dbg, 1'b0, 1'b0, 1'b0);
|
||||
|
||||
// In all modes, let the ADC's outputs be enabled.
|
||||
assign adc_noe = 1'b0;
|
||||
|
||||
endmodule
|
443
fpga-xc2s30/hi_reader_15.v
Normal file
443
fpga-xc2s30/hi_reader_15.v
Normal file
|
@ -0,0 +1,443 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// copied from hi_reader.v by Jonathan Westhues, April 2006
|
||||
// modified to add support for iso15 2sc mode by lnv42, Feb 2022
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
module hi_reader(
|
||||
ck_1356meg,
|
||||
pwr_lo, pwr_hi, pwr_oe1, pwr_oe2, pwr_oe3, pwr_oe4,
|
||||
adc_d, adc_clk,
|
||||
ssp_frame, ssp_din, ssp_dout, ssp_clk,
|
||||
dbg,
|
||||
subcarrier_frequency, minor_mode
|
||||
);
|
||||
input ck_1356meg;
|
||||
output pwr_lo, pwr_hi, pwr_oe1, pwr_oe2, pwr_oe3, pwr_oe4;
|
||||
input [7:0] adc_d;
|
||||
output adc_clk;
|
||||
input ssp_dout;
|
||||
output ssp_frame, ssp_din, ssp_clk;
|
||||
output dbg;
|
||||
input [1:0] subcarrier_frequency;
|
||||
input [3:0] minor_mode;
|
||||
|
||||
assign adc_clk = ck_1356meg; // sample frequency is 13,56 MHz
|
||||
|
||||
// When we're a reader, we just need to do the BPSK demod; but when we're an
|
||||
// eavesdropper, we also need to pick out the commands sent by the reader,
|
||||
// using AM. Do this the same way that we do it for the simulated tag.
|
||||
reg after_hysteresis, after_hysteresis_prev, after_hysteresis_prev_prev;
|
||||
reg [11:0] has_been_low_for;
|
||||
always @(negedge adc_clk)
|
||||
begin
|
||||
if (& adc_d[7:0]) after_hysteresis <= 1'b1;
|
||||
else if (~(| adc_d[7:0])) after_hysteresis <= 1'b0;
|
||||
|
||||
if (after_hysteresis)
|
||||
begin
|
||||
has_been_low_for <= 12'd0;
|
||||
end
|
||||
else
|
||||
begin
|
||||
if (has_been_low_for == 12'd4095)
|
||||
begin
|
||||
has_been_low_for <= 12'd0;
|
||||
after_hysteresis <= 1'b1;
|
||||
end
|
||||
else
|
||||
has_been_low_for <= has_been_low_for + 1;
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
// Let us report a correlation every 64 samples. I.e.
|
||||
// one Q/I pair after 4 subcarrier cycles for the 848kHz subcarrier,
|
||||
// one Q/I pair after 2 subcarrier cycles for the 424kHz subcarriers,
|
||||
// one Q/I pair for each subcarrier cyle for the 212kHz subcarrier.
|
||||
// We need a 6-bit counter for the timing.
|
||||
reg [5:0] corr_i_cnt;
|
||||
always @(negedge adc_clk)
|
||||
begin
|
||||
corr_i_cnt <= corr_i_cnt + 1;
|
||||
end
|
||||
|
||||
|
||||
reg [1:0] fskout = 2'd0;
|
||||
reg last0 = 1'b0;
|
||||
|
||||
reg [7:0] avg = 8'd0;
|
||||
reg [127:0] avg128 = 128'd0;
|
||||
reg [7:0] diff16 = 8'd0;
|
||||
reg [7:0] diff28 = 8'd0;
|
||||
reg [7:0] diff32 = 8'd0;
|
||||
|
||||
reg [11:0] match16 = 12'd0;
|
||||
reg [11:0] match32 = 12'd0;
|
||||
reg [11:0] match28 = 12'd0;
|
||||
|
||||
always @(negedge adc_clk)
|
||||
begin
|
||||
if (corr_i_cnt[0] == 1'b0) // every 2 clock
|
||||
begin
|
||||
avg = adc_d[7:1];
|
||||
end
|
||||
else
|
||||
begin
|
||||
avg = avg + adc_d[7:1];
|
||||
if (corr_i_cnt[0] == 1'b1) // every 2 clock
|
||||
begin
|
||||
if (avg > avg128[63:56])
|
||||
diff16 = avg - avg128[63:56];
|
||||
else
|
||||
diff16 = avg128[63:56] - avg;
|
||||
|
||||
if (avg > avg128[111:104])
|
||||
diff28 = avg - avg128[111:104];
|
||||
else
|
||||
diff28 = avg128[111:104] - avg;
|
||||
|
||||
if (avg > avg128[127:120])
|
||||
diff32 = avg - avg128[127:120];
|
||||
else
|
||||
diff32 = avg128[127:120] - avg;
|
||||
|
||||
avg128[127:8] = avg128[119:0];
|
||||
avg128[7:0] = avg;
|
||||
|
||||
|
||||
if (corr_i_cnt[4:1] == 4'b0000) // every 32 clock (8*4)
|
||||
begin
|
||||
match16 = diff16;
|
||||
match28 = diff28;
|
||||
match32 = diff32;
|
||||
end
|
||||
else
|
||||
begin
|
||||
match16 = match16 + diff16;
|
||||
match28 = match28 + diff28;
|
||||
match32 = match32 + diff32;
|
||||
|
||||
if (corr_i_cnt[4:1] == 4'b1111) // every 32 clock (8*4)
|
||||
begin
|
||||
last0 = (fskout == 2'b0);
|
||||
if (match16 < 12'd64 && last0)
|
||||
fskout = 2'b00; // not yet started
|
||||
else if ((match16 | match28 | match32) == 12'b0)
|
||||
fskout = 2'b00; // signal likely ended
|
||||
else if (((match16 <= match28 + 12'd16) && (match16 <= match32+ 12'd16)) ||
|
||||
(match28 <= 12'd16 && match32 <= 12'd16))
|
||||
begin
|
||||
if (!last0)
|
||||
fskout = 2'b11; // 16 match better than 28 or 32 but already started
|
||||
end
|
||||
else
|
||||
begin
|
||||
if (match28 < match32)
|
||||
begin
|
||||
diff28 = match32 - match28;
|
||||
diff16 = match16 - match28;
|
||||
if (diff28*2 > diff16)
|
||||
fskout = 2'b01;
|
||||
else if (!last0)
|
||||
begin
|
||||
fskout = 2'b01;
|
||||
end
|
||||
end
|
||||
else //if (match32 <= match28)
|
||||
begin
|
||||
diff32 = match28 - match32;
|
||||
diff16 = match16 - match32;
|
||||
if (diff32*2 > diff16)
|
||||
fskout = 2'b10;
|
||||
else if (!last0)
|
||||
begin
|
||||
fskout = 2'b10;
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
// A couple of registers in which to accumulate the correlations. From the 64 samples
|
||||
// we would add at most 32 times the difference between unmodulated and modulated signal. It should
|
||||
// be safe to assume that a tag will not be able to modulate the carrier signal by more than 25%.
|
||||
// 32 * 255 * 0,25 = 2040, which can be held in 11 bits. Add 1 bit for sign.
|
||||
// Temporary we might need more bits. For the 212kHz subcarrier we could possible add 32 times the
|
||||
// maximum signal value before a first subtraction would occur. 32 * 255 = 8160 can be held in 13 bits.
|
||||
// Add one bit for sign -> need 14 bit registers but final result will fit into 12 bits.
|
||||
reg signed [13:0] corr_i_accum;
|
||||
reg signed [13:0] corr_q_accum;
|
||||
// we will report maximum 8 significant bits
|
||||
reg signed [7:0] corr_i_out;
|
||||
reg signed [7:0] corr_q_out;
|
||||
|
||||
|
||||
// the amplitude of the subcarrier is sqrt(ci^2 + cq^2).
|
||||
// approximate by amplitude = max(|ci|,|cq|) + 1/2*min(|ci|,|cq|)
|
||||
reg [13:0] corr_amplitude, abs_ci, abs_cq, max_ci_cq;
|
||||
reg [12:0] min_ci_cq_2; // min_ci_cq / 2
|
||||
|
||||
always @(*)
|
||||
begin
|
||||
if (corr_i_accum[13] == 1'b0)
|
||||
abs_ci <= corr_i_accum;
|
||||
else
|
||||
abs_ci <= -corr_i_accum;
|
||||
|
||||
if (corr_q_accum[13] == 1'b0)
|
||||
abs_cq <= corr_q_accum;
|
||||
else
|
||||
abs_cq <= -corr_q_accum;
|
||||
|
||||
if (abs_ci > abs_cq)
|
||||
begin
|
||||
max_ci_cq <= abs_ci;
|
||||
min_ci_cq_2 <= abs_cq / 2;
|
||||
end
|
||||
else
|
||||
begin
|
||||
max_ci_cq <= abs_cq;
|
||||
min_ci_cq_2 <= abs_ci / 2;
|
||||
end
|
||||
|
||||
corr_amplitude <= max_ci_cq + min_ci_cq_2;
|
||||
|
||||
end
|
||||
|
||||
|
||||
// The subcarrier reference signals
|
||||
reg subcarrier_I;
|
||||
reg subcarrier_Q;
|
||||
|
||||
always @(*)
|
||||
begin
|
||||
if (subcarrier_frequency == `FPGA_HF_READER_SUBCARRIER_848_KHZ)
|
||||
begin
|
||||
subcarrier_I = ~corr_i_cnt[3];
|
||||
subcarrier_Q = ~(corr_i_cnt[3] ^ corr_i_cnt[2]);
|
||||
end
|
||||
else if (subcarrier_frequency == `FPGA_HF_READER_SUBCARRIER_212_KHZ)
|
||||
begin
|
||||
subcarrier_I = ~corr_i_cnt[5];
|
||||
subcarrier_Q = ~(corr_i_cnt[5] ^ corr_i_cnt[4]);
|
||||
end
|
||||
else
|
||||
begin // 424 kHz
|
||||
subcarrier_I = ~corr_i_cnt[4];
|
||||
subcarrier_Q = ~(corr_i_cnt[4] ^ corr_i_cnt[3]);
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
// ADC data appears on the rising edge, so sample it on the falling edge
|
||||
always @(negedge adc_clk)
|
||||
begin
|
||||
// These are the correlators: we correlate against in-phase and quadrature
|
||||
// versions of our reference signal, and keep the (signed) results or the
|
||||
// resulting amplitude to send out later over the SSP.
|
||||
if (corr_i_cnt == 6'd0)
|
||||
begin
|
||||
if (minor_mode == `FPGA_HF_READER_MODE_SNIFF_AMPLITUDE)
|
||||
begin
|
||||
if (subcarrier_frequency == `FPGA_HF_READER_2SUBCARRIERS_424_484_KHZ)
|
||||
begin
|
||||
// send amplitude + 2 bits fsk (2sc) signal + 2 bits reader signal
|
||||
corr_i_out <= corr_amplitude[13:6];
|
||||
corr_q_out <= {corr_amplitude[5:2], fskout, after_hysteresis_prev_prev, after_hysteresis_prev};
|
||||
end
|
||||
else
|
||||
begin
|
||||
// send amplitude plus 2 bits reader signal
|
||||
corr_i_out <= corr_amplitude[13:6];
|
||||
corr_q_out <= {corr_amplitude[5:0], after_hysteresis_prev_prev, after_hysteresis_prev};
|
||||
end
|
||||
end
|
||||
else if (minor_mode == `FPGA_HF_READER_MODE_SNIFF_IQ)
|
||||
begin
|
||||
// Send 7 most significant bits of in phase tag signal (signed), plus 1 bit reader signal
|
||||
if (corr_i_accum[13:11] == 3'b000 || corr_i_accum[13:11] == 3'b111)
|
||||
corr_i_out <= {corr_i_accum[11:5], after_hysteresis_prev_prev};
|
||||
else // truncate to maximum value
|
||||
if (corr_i_accum[13] == 1'b0)
|
||||
corr_i_out <= {7'b0111111, after_hysteresis_prev_prev};
|
||||
else
|
||||
corr_i_out <= {7'b1000000, after_hysteresis_prev_prev};
|
||||
|
||||
// Send 7 most significant bits of quadrature phase tag signal (signed), plus 1 bit reader signal
|
||||
if (corr_q_accum[13:11] == 3'b000 || corr_q_accum[13:11] == 3'b111)
|
||||
corr_q_out <= {corr_q_accum[11:5], after_hysteresis_prev};
|
||||
else // truncate to maximum value
|
||||
if (corr_q_accum[13] == 1'b0)
|
||||
corr_q_out <= {7'b0111111, after_hysteresis_prev};
|
||||
else
|
||||
corr_q_out <= {7'b1000000, after_hysteresis_prev};
|
||||
end
|
||||
else if (minor_mode == `FPGA_HF_READER_MODE_RECEIVE_AMPLITUDE)
|
||||
begin
|
||||
// send amplitude
|
||||
corr_i_out <= {2'b00, corr_amplitude[13:8]};
|
||||
corr_q_out <= corr_amplitude[7:0];
|
||||
end
|
||||
else if (minor_mode == `FPGA_HF_READER_MODE_RECEIVE_IQ)
|
||||
begin
|
||||
// Send 8 bits of in phase tag signal
|
||||
if (corr_i_accum[13:11] == 3'b000 || corr_i_accum[13:11] == 3'b111)
|
||||
corr_i_out <= corr_i_accum[11:4];
|
||||
else // truncate to maximum value
|
||||
if (corr_i_accum[13] == 1'b0)
|
||||
corr_i_out <= 8'b01111111;
|
||||
else
|
||||
corr_i_out <= 8'b10000000;
|
||||
|
||||
// Send 8 bits of quadrature phase tag signal
|
||||
if (corr_q_accum[13:11] == 3'b000 || corr_q_accum[13:11] == 3'b111)
|
||||
corr_q_out <= corr_q_accum[11:4];
|
||||
else // truncate to maximum value
|
||||
if (corr_q_accum[13] == 1'b0)
|
||||
corr_q_out <= 8'b01111111;
|
||||
else
|
||||
corr_q_out <= 8'b10000000;
|
||||
end
|
||||
|
||||
// for each Q/I pair report two reader signal samples when sniffing. Store the 1st.
|
||||
after_hysteresis_prev_prev <= after_hysteresis;
|
||||
|
||||
// Initialize next correlation.
|
||||
// Both I and Q reference signals are high when corr_i_nct == 0. Therefore need to accumulate.
|
||||
corr_i_accum <= $signed({1'b0, adc_d});
|
||||
corr_q_accum <= $signed({1'b0, adc_d});
|
||||
end
|
||||
else
|
||||
begin
|
||||
if (subcarrier_I)
|
||||
corr_i_accum <= corr_i_accum + $signed({1'b0, adc_d});
|
||||
else
|
||||
corr_i_accum <= corr_i_accum - $signed({1'b0, adc_d});
|
||||
|
||||
if (subcarrier_Q)
|
||||
corr_q_accum <= corr_q_accum + $signed({1'b0, adc_d});
|
||||
else
|
||||
corr_q_accum <= corr_q_accum - $signed({1'b0, adc_d});
|
||||
end
|
||||
|
||||
// for each Q/I pair report two reader signal samples when sniffing. Store the 2nd.
|
||||
if (corr_i_cnt == 6'd32)
|
||||
after_hysteresis_prev <= after_hysteresis;
|
||||
|
||||
// Then the result from last time is serialized and send out to the ARM.
|
||||
// We get one report each cycle, and each report is 16 bits, so the
|
||||
// ssp_clk should be the adc_clk divided by 64/16 = 4.
|
||||
// ssp_clk frequency = 13,56MHz / 4 = 3.39MHz
|
||||
|
||||
if (corr_i_cnt[1:0] == 2'b00)
|
||||
begin
|
||||
// Don't shift if we just loaded new data, obviously.
|
||||
if (corr_i_cnt != 6'd0)
|
||||
begin
|
||||
corr_i_out[7:0] <= {corr_i_out[6:0], corr_q_out[7]};
|
||||
corr_q_out[7:1] <= corr_q_out[6:0];
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
// ssp clock and frame signal for communication to and from ARM
|
||||
// _____ _____ _____ _
|
||||
// ssp_clk | |_____| |_____| |_____|
|
||||
// _____
|
||||
// ssp_frame ___| |____________________________
|
||||
// ___________ ___________ ___________ _
|
||||
// ssp_d_in X___________X___________X___________X_
|
||||
//
|
||||
// corr_i_cnt 0 1 2 3 4 5 6 7 8 9 10 11 12 ...
|
||||
//
|
||||
|
||||
reg ssp_clk;
|
||||
reg ssp_frame;
|
||||
|
||||
always @(negedge adc_clk)
|
||||
begin
|
||||
if (corr_i_cnt[1:0] == 2'b00)
|
||||
ssp_clk <= 1'b1;
|
||||
|
||||
if (corr_i_cnt[1:0] == 2'b10)
|
||||
ssp_clk <= 1'b0;
|
||||
|
||||
// set ssp_frame signal for corr_i_cnt = 1..3
|
||||
// (send one frame with 16 Bits)
|
||||
if (corr_i_cnt == 6'd1)
|
||||
ssp_frame <= 1'b1;
|
||||
|
||||
if (corr_i_cnt == 6'd3)
|
||||
ssp_frame <= 1'b0;
|
||||
end
|
||||
|
||||
|
||||
assign ssp_din = corr_i_out[7];
|
||||
|
||||
|
||||
// a jamming signal
|
||||
reg jam_signal;
|
||||
reg [3:0] jam_counter;
|
||||
|
||||
always @(negedge adc_clk)
|
||||
begin
|
||||
if (corr_i_cnt == 6'd0)
|
||||
begin
|
||||
jam_counter <= jam_counter + 1;
|
||||
jam_signal <= jam_counter[1] ^ jam_counter[3];
|
||||
end
|
||||
end
|
||||
|
||||
// Antenna drivers
|
||||
reg pwr_hi, pwr_oe4;
|
||||
|
||||
always @(*)
|
||||
begin
|
||||
if (minor_mode == `FPGA_HF_READER_MODE_SEND_SHALLOW_MOD)
|
||||
begin
|
||||
pwr_hi = ck_1356meg;
|
||||
pwr_oe4 = ssp_dout;
|
||||
end
|
||||
else if (minor_mode == `FPGA_HF_READER_MODE_SEND_FULL_MOD)
|
||||
begin
|
||||
pwr_hi = ck_1356meg & ~ssp_dout;
|
||||
pwr_oe4 = 1'b0;
|
||||
end
|
||||
else if (minor_mode == `FPGA_HF_READER_MODE_SEND_JAM)
|
||||
begin
|
||||
pwr_hi = ck_1356meg & jam_signal;
|
||||
pwr_oe4 = 1'b0;
|
||||
end
|
||||
else if (minor_mode == `FPGA_HF_READER_MODE_SNIFF_IQ
|
||||
|| minor_mode == `FPGA_HF_READER_MODE_SNIFF_AMPLITUDE
|
||||
|| minor_mode == `FPGA_HF_READER_MODE_SNIFF_PHASE)
|
||||
begin // all off
|
||||
pwr_hi = 1'b0;
|
||||
pwr_oe4 = 1'b0;
|
||||
end
|
||||
else // receiving from tag
|
||||
begin
|
||||
pwr_hi = ck_1356meg;
|
||||
pwr_oe4 = 1'b0;
|
||||
end
|
||||
end
|
||||
|
||||
// always on
|
||||
assign pwr_oe1 = 1'b0;
|
||||
assign pwr_oe3 = 1'b0;
|
||||
|
||||
// Unused.
|
||||
assign pwr_lo = 1'b0;
|
||||
assign pwr_oe2 = 1'b0;
|
||||
|
||||
// Debug Output
|
||||
assign dbg = corr_i_cnt[3];
|
||||
|
||||
endmodule
|
1
fpga-xc2s30/xst_hf_15.scr
Normal file
1
fpga-xc2s30/xst_hf_15.scr
Normal file
|
@ -0,0 +1 @@
|
|||
run -ifn fpga_hf_15.v -ifmt Verilog -ofn fpga_hf_15.ngc -ofmt NGC -p xc2s30-5-vq100 -top fpga_hf_15 -opt_mode area -opt_level 2 -resource_sharing yes -fsm_style bram -fsm_encoding compact
|
Loading…
Reference in a new issue