#ifndef _JTAG_XSVF_PLAYER_H_ #define _JTAG_XSVF_PLAYER_H_ /* Arduino JTAG Player for Afterburner GAL project --------------------------------------- Adapted from JTAG library 1.0.15 by Marcelo Jimenez https://github.com/mrjimenez/JTAG This port: * improves flash size on AVR MCU (about 6.5kb vs 11kb) * allows to allocate JTAG internal buffers temporarily within a shared global buffer (heap). Define XSVF_HEAP to enable such feature: uint8_t heap[900]; #define XSVF_HEAP heap #include "jtag_xsvf_player.h" * reduces the code to a single .h file Use the original JTAG libray python scripts to upload XSVF files from your PC: ./xsvf -p /dev/ttyACM0 my_file.xsvf Arduino usage: jtag_port_t jport; Serial.begin(115200); //assign jtag pins (vref pin checks the cable is plugged in) jport.tms = 12; jport.tdi = 2; jport.tdo = 4; jport.tck = 3; jport.vref = 10; //process XSVF data received from serial port jtag_play_xsvf(&jport); */ //value bigger than 63 may cause reading errors on AVR MCUs. #define XSVF_BUF_SIZE 62 #define XSVF_DEBUG 0 #define XSVF_CALC_CSUM 1 #define XSVF_IGNORE_NOMATCH 0 #define XCOMPLETE 0 #define XTDOMASK 1 #define XSIR 2 #define XSDR 3 #define XRUNTEST 4 #define XRESERVED_5 5 #define XRESERVED_6 6 #define XREPEAT 7 #define XSDRSIZE 8 #define XSDRTDO 9 #define XSETSDRMASKS 10 #define XSDRINC 11 #define XSDRB 12 #define XSDRC 13 #define XSDRE 14 #define XSDRTDOB 15 #define XSDRTDOC 16 #define XSDRTDOE 17 #define XSTATE 18 #define XENDIR 19 #define XENDDR 20 #define XSIR2 21 #define XCOMMENT 22 #define XWAIT 23 #define XWAITSTATE 24 #define XTRST 28 #define S_MAX_CHAIN_SIZE_BYTES 129 #define S_MAX_CHAIN_SIZE_BITS (S_MAX_CHAIN_SIZE_BYTES * 8) #define STATE_RUN_TEST_IDLE 1 #define STATE_PAUSE_DR 6 #define STATE_PAUSE_IR 13 #define ERR_IO 1 #define ERR_XSIR_SIZE 2 #define ERR_XSDRSIZE 3 #define ERR_XENDIR 4 #define ERR_XENDDR 5 #define ERR_XSDR 6 #define ERR_INSTR_NOT_IMPLEMENTED 99 #define ERR_DR_CHECK_FAILED 101 /* * Low nibble : TMS == 0 * High nibble: TMS == 1 */ #define TMS_T(TMS_HIGH_STATE, TMS_LOW_STATE) (((TMS_HIGH_STATE) << 4) | (TMS_LOW_STATE)) #define XSTATE_TEST_LOGIC_RESET 0 #define XSTATE_RUN_TEST_IDLE 1 #define XSTATE_SELECT_DR_SCAN 2 #define XSTATE_CAPTURE_DR 3 #define XSTATE_SHIFT_DR 4 #define XSTATE_EXIT1_DR 5 #define XSTATE_PAUSE_DR 6 #define XSTATE_EXIT2_DR 7 #define XSTATE_UPDATE_DR 8 #define XSTATE_SELECT_IR_SCAN 9 #define XSTATE_CAPTURE_IR 10 #define XSTATE_SHIFT_IR 11 #define XSTATE_EXIT1_IR 12 #define XSTATE_PAUSE_IR 13 #define XSTATE_EXIT2_IR 14 #define XSTATE_UPDATE_IR 15 #define TMS_T00 /* STATE_TEST_LOGIC_RESET */ TMS_T(XSTATE_TEST_LOGIC_RESET, XSTATE_RUN_TEST_IDLE) #define TMS_T01 /* STATE_RUN_TEST_IDLE */ TMS_T(XSTATE_SELECT_DR_SCAN, XSTATE_RUN_TEST_IDLE) #define TMS_T02 /* STATE_SELECT_DR_SCAN */ TMS_T(XSTATE_SELECT_IR_SCAN, XSTATE_CAPTURE_DR) #define TMS_T03 /* STATE_CAPTURE_DR */ TMS_T(XSTATE_EXIT1_DR, XSTATE_SHIFT_DR) #define TMS_T04 /* STATE_SHIFT_DR */ TMS_T(XSTATE_EXIT1_DR, XSTATE_SHIFT_DR) #define TMS_T05 /* STATE_EXIT1_DR */ TMS_T(XSTATE_UPDATE_DR, XSTATE_PAUSE_DR) #define TMS_T06 /* STATE_PAUSE_DR */ TMS_T(XSTATE_EXIT2_DR, XSTATE_PAUSE_DR) #define TMS_T07 /* STATE_EXIT2_DR */ TMS_T(XSTATE_UPDATE_DR, XSTATE_SHIFT_DR) #define TMS_T08 /* STATE_UPDATE_DR */ TMS_T(XSTATE_SELECT_DR_SCAN, XSTATE_RUN_TEST_IDLE) #define TMS_T09 /* STATE_SELECT_IR_SCAN */ TMS_T(XSTATE_TEST_LOGIC_RESET, XSTATE_CAPTURE_IR) #define TMS_T10 /* STATE_CAPTURE_IR */ TMS_T(XSTATE_EXIT1_IR, XSTATE_SHIFT_IR) #define TMS_T11 /* STATE_SHIFT_IR */ TMS_T(XSTATE_EXIT1_IR, XSTATE_SHIFT_IR) #define TMS_T12 /* STATE_EXIT1_IR */ TMS_T(XSTATE_UPDATE_IR, XSTATE_PAUSE_IR) #define TMS_T13 /* STATE_PAUSE_IR */ TMS_T(XSTATE_EXIT2_IR, XSTATE_PAUSE_IR) #define TMS_T14 /* STATE_EXIT2_IR */ TMS_T(XSTATE_UPDATE_IR, XSTATE_SHIFT_IR) #define TMS_T15 /* STATE_UPDATE_IR */ TMS_T(XSTATE_SELECT_DR_SCAN, XSTATE_RUN_TEST_IDLE) #define BITSTR(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ( \ ((uint16_t)(A) << 15) | \ ((uint16_t)(B) << 14) | \ ((uint16_t)(C) << 13) | \ ((uint16_t)(D) << 12) | \ ((uint16_t)(E) << 11) | \ ((uint16_t)(F) << 10) | \ ((uint16_t)(G) << 9) | \ ((uint16_t)(H) << 8) | \ ((uint16_t)(I) << 7) | \ ((uint16_t)(J) << 6) | \ ((uint16_t)(K) << 5) | \ ((uint16_t)(L) << 4) | \ ((uint16_t)(M) << 3) | \ ((uint16_t)(N) << 2) | \ ((uint16_t)(O) << 1) | \ ((uint16_t)(P) << 0) ) /* * The index of this vector is the current state. The i-th bit tells you the * value TMS must assume in order to go to state "i". ------------------------------------------------------------------------------------------------------------ | | || F | E | D | C || B | A | 9 | 8 || 7 | 6 | 5 | 4 || 3 | 2 | 1 | 0 || HEX | ------------------------------------------------------------------------------------------------------------ | STATE_TEST_LOGIC_RESET | 0 || 0 | 0 | 0 | 0 || 0 | 0 | 0 | 0 || 0 | 0 | 0 | 0 || 0 | 0 | 0 | 1 || 0x0001 | | STATE_RUN_TEST_IDLE | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 0 | 1 || 0xFFFD | | STATE_SELECT_DR_SCAN | 2 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 0 || 0 | 0 | 0 | 0 || 0 | x | 1 | 1 || 0xFE03 | | STATE_CAPTURE_DR | 3 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 0 || x | 1 | 1 | 1 || 0xFFE7 | | STATE_SHIFT_DR | 4 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 0 || 1 | 1 | 1 | 1 || 0xFFEF | | STATE_EXIT1_DR | 5 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0 | 0 | x | 0 || 1 | 1 | 1 | 1 || 0xFF0F | | STATE_PAUSE_DR | 6 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 0 | 1 | 1 || 1 | 1 | 1 | 1 || 0xFFBF | | STATE_EXIT2_DR | 7 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || x | 0 | 0 | 0 || 1 | 1 | 1 | 1 || 0xFF0F | | STATE_UPDATE_DR | 8 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | x || 1 | 1 | 1 | 1 || 1 | 1 | 0 | 1 || 0xFEFD | | STATE_SELECT_IR_SCAN | 9 || 0 | 0 | 0 | 0 || 0 | 0 | x | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0x01FF | | STATE_CAPTURE_IR | A || 1 | 1 | 1 | 1 || 0 | x | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0xF3FF | | STATE_SHIFT_IR | B || 1 | 1 | 1 | 1 || 0 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0xF7FF | | STATE_EXIT1_IR | C || 1 | 0 | 0 | x || 0 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0x87FF | | STATE_PAUSE_IR | D || 1 | 1 | 0 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0xDFFF | | STATE_EXIT2_IR | E || 1 | x | 0 | 0 || 0 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 0x87FF | | STATE_UPDATE_IR | F || x | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 1 | 1 || 1 | 1 | 0 | 1 || 0x7FFD | ------------------------------------------------------------------------------------------------------------ */ #define BS00 /* STATE_TEST_LOGIC_RESET */ BITSTR( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ) #define BS01 /* STATE_RUN_TEST_IDLE */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1 ) #define BS02 /* STATE_SELECT_DR_SCAN */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1 ) #define BS03 /* STATE_CAPTURE_DR */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 ) #define BS04 /* STATE_SHIFT_DR */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 ) #define BS05 /* STATE_EXIT1_DR */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 ) #define BS06 /* STATE_PAUSE_DR */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 ) #define BS07 /* STATE_EXIT2_DR */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 ) #define BS08 /* STATE_UPDATE_DR */ BITSTR( 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 ) #define BS09 /* STATE_SELECT_IR_SCAN */ BITSTR( 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) #define BS10 /* STATE_CAPTURE_IR */ BITSTR( 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) #define BS11 /* STATE_SHIFT_IR */ BITSTR( 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) #define BS12 /* STATE_EXIT1_IR */ BITSTR( 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) #define BS13 /* STATE_PAUSE_IR */ BITSTR( 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) #define BS14 /* STATE_EXIT2_IR */ BITSTR( 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) #define BS15 /* STATE_UPDATE_IR */ BITSTR( 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1 ) typedef struct xsvf_t { uint8_t* xsvf_tdo_mask; uint8_t* xsvf_tdi; uint8_t* xsvf_tdo; uint8_t* xsvf_tdo_expected; uint8_t* xsvf_address_mask; uint8_t* xsvf_data_mask; uint32_t rdpos; uint32_t wrpos; #if XSVF_CALC_CSUM uint32_t csum; #endif uint16_t instruction_counter; uint8_t error; uint8_t xcomplete; uint16_t sirsize_bits; uint16_t sirsize_bytes; uint32_t sdrsize_bits; uint32_t sdrsize_bytes; uint32_t runtest; uint8_t repeat; uint8_t next_state; uint8_t endir_state; uint8_t enddr_state; uint32_t wait_time_usecs; uint8_t wait_start_state; uint8_t wait_end_state; uint8_t jtag_current_state; } xsvf_t; #ifdef XSVF_HEAP // variables will be allocated on heap uint8_t* xsvf_buf; xsvf_t* xsvf; uint8_t* xsvf_tms_transitions; uint16_t* xsvf_tms_map; #else /* XSVF_HEAP */ // variables allocated globally uint8_t xsvf_buf[XSVF_BUF_SIZE]; uint8_t xsvf_tdo_mask[S_MAX_CHAIN_SIZE_BYTES]; uint8_t xsvf_tdi[S_MAX_CHAIN_SIZE_BYTES]; uint8_t xsvf_tdo[S_MAX_CHAIN_SIZE_BYTES]; uint8_t xsvf_tdo_expected[S_MAX_CHAIN_SIZE_BYTES]; uint8_t xsvf_address_mask[S_MAX_CHAIN_SIZE_BYTES]; uint8_t xsvf_data_mask[S_MAX_CHAIN_SIZE_BYTES]; xsvf_t xsvf_context; xsvf_t* xsvf = &xsvf_context; static const uint8_t xsvf_tms_transitions[] = { TMS_T00, TMS_T01, TMS_T02, TMS_T03, TMS_T04, TMS_T05, TMS_T06, TMS_T07, TMS_T08, TMS_T09, TMS_T10, TMS_T11, TMS_T12, TMS_T13, TMS_T14, TMS_T15, }; static const uint16_t xsvf_tms_map[] = { BS00, BS01, BS02, BS03, BS04, BS05, BS06, BS07, BS08, BS09, BS10, BS11, BS12, BS13, BS14, BS15 }; #endif typedef struct jtag_port_t { uint8_t tms; uint8_t tdi; uint8_t tdo; uint8_t tck; uint8_t vref; } jtag_port_t; static void jtag_port_init(jtag_port_t* port) { pinMode(port->tms, OUTPUT); pinMode(port->tdi, OUTPUT); pinMode(port->tck, OUTPUT); pinMode(port->tdo, INPUT); pinMode(port->vref, INPUT); } static void jtag_port_pulse_clock(jtag_port_t* port) { digitalWrite(port->tck, 0); delayMicroseconds(1); digitalWrite(port->tck, 1); } static uint8_t jtag_port_pulse_clock_read_tdo(jtag_port_t* port) { uint8_t val; digitalWrite(port->tck, 0); delayMicroseconds(1); val = digitalRead(port->tdo); digitalWrite(port->tck, 1); return val; } static inline void jtag_port_set_tms(jtag_port_t* port, uint8_t val) { digitalWrite(port->tms, val); } static inline void jtag_port_set_tdi(jtag_port_t* port, uint8_t val) { digitalWrite(port->tdi, val); } static inline uint8_t jtag_port_get_veref(jtag_port_t* port) { return digitalRead(port->vref); } static uint8_t xsvf_player_next_byte(void) { uint8_t retry = 16; uint8_t pos = xsvf->rdpos % XSVF_BUF_SIZE; if (xsvf->wrpos == xsvf->rdpos) { size_t r = 0; while (r == 0) { #if XSVF_DEBUG Serial.println("D<<< req read"); // request to receive BUF size bytes #endif Serial.println(F("$062")); // request to receive BUF size bytes r = Serial.readBytes(xsvf_buf + pos, XSVF_BUF_SIZE - pos); #if XSVF_DEBUG Serial.print("D<<< read "); // request to receive BUF size bytes Serial.println(r, DEC); // request to receive BUF size bytes #endif if (r == 0) { retry --; if (retry == 0) { xsvf->error = 1; return 0; } delay(1); } else { xsvf->wrpos += r; } } } xsvf->rdpos++; #if XSVF_DEBUG Serial.print(F("D BYTE ")); Serial.print(xsvf_buf[pos], DEC); Serial.print(F(" 0x")); Serial.println(xsvf_buf[pos], HEX); #endif #if XSVF_CALC_CSUM xsvf->csum += xsvf_buf[pos]; #endif return xsvf_buf[pos]; } static uint8_t xsvf_player_get_next_byte(void) { return xsvf_player_next_byte(); } /* static uint16_t xsvf_player_get_next_word(void) { uint16_t i = xsvf_player_next_byte(); i <<= 8; i |= xsvf_player_next_byte(); return i; } */ static uint32_t xsvf_player_get_next_long(void) { uint32_t i = xsvf_player_next_byte(); i <<= 8; i |= xsvf_player_next_byte(); i <<= 8; i |= xsvf_player_next_byte(); i <<= 8; i |= xsvf_player_next_byte(); return i; } static void xsvf_player_get_next_bytes(uint8_t* data, uint32_t count) { while(count--) { *data++ = xsvf_player_next_byte(); } } #ifdef XSVF_HEAP static uint32_t xsvf_heap_pos(uint32_t* pos, uint16_t size) { uint32_t heap_pos = *pos; //allocate on 4 byte boundaries heap_pos = (heap_pos + 3) & 0xFFFFFFFC; *pos = heap_pos + size; return heap_pos; } #endif static void xsvf_clear() { uint16_t i; uint8_t* d = (uint8_t*) xsvf; //clear the xsvf data in RAM i = sizeof(xsvf_t); while(i) { i--; d[i] = 0; } } static void xsvf_player_init(jtag_port_t* port) { jtag_port_init(port); #ifdef XSVF_HEAP { // variables allocated on the heap uint32_t heap_pos = (uint32_t) XSVF_HEAP; xsvf = (xsvf_t*) xsvf_heap_pos(&heap_pos, sizeof(xsvf_t)); xsvf_buf = (uint8_t*) xsvf_heap_pos(&heap_pos, XSVF_BUF_SIZE); xsvf_clear(); xsvf->xsvf_tdo_mask = (uint8_t*) xsvf_heap_pos(&heap_pos, S_MAX_CHAIN_SIZE_BYTES); xsvf->xsvf_tdi = (uint8_t*) xsvf_heap_pos(&heap_pos, S_MAX_CHAIN_SIZE_BYTES); xsvf->xsvf_tdo = (uint8_t*) xsvf_heap_pos(&heap_pos, S_MAX_CHAIN_SIZE_BYTES); xsvf->xsvf_tdo_expected = (uint8_t*) xsvf_heap_pos(&heap_pos, S_MAX_CHAIN_SIZE_BYTES); xsvf->xsvf_address_mask = (uint8_t*) xsvf_heap_pos(&heap_pos, S_MAX_CHAIN_SIZE_BYTES); xsvf->xsvf_data_mask = (uint8_t*) xsvf_heap_pos(&heap_pos, S_MAX_CHAIN_SIZE_BYTES); xsvf_tms_transitions = (uint8_t*) xsvf_heap_pos(&heap_pos, 16); xsvf_tms_map = (uint16_t*) xsvf_heap_pos(&heap_pos, 32); if (heap_pos - ((uint32_t)XSVF_HEAP) > sizeof(XSVF_HEAP)) { Serial.print(F("Q-1,ERROR: Heap is small:")); Serial.println(heap_pos - ((uint32_t)XSVF_HEAP), DEC); return; } //set up TM transitions xsvf_tms_transitions[0] = TMS_T00; xsvf_tms_transitions[1] = TMS_T01; xsvf_tms_transitions[2] = TMS_T02; xsvf_tms_transitions[3] = TMS_T03; xsvf_tms_transitions[4] = TMS_T04; xsvf_tms_transitions[5] = TMS_T05; xsvf_tms_transitions[6] = TMS_T06; xsvf_tms_transitions[7] = TMS_T07; xsvf_tms_transitions[8] = TMS_T08; xsvf_tms_transitions[9] = TMS_T09; xsvf_tms_transitions[10] = TMS_T10; xsvf_tms_transitions[11] = TMS_T11; xsvf_tms_transitions[12] = TMS_T12; xsvf_tms_transitions[13] = TMS_T13; xsvf_tms_transitions[14] = TMS_T14; xsvf_tms_transitions[15] = TMS_T15; //set up bitstream map xsvf_tms_map[0] = BS00; xsvf_tms_map[1] = BS01; xsvf_tms_map[2] = BS02; xsvf_tms_map[3] = BS03; xsvf_tms_map[4] = BS04; xsvf_tms_map[5] = BS05; xsvf_tms_map[6] = BS06; xsvf_tms_map[7] = BS07; xsvf_tms_map[8] = BS08; xsvf_tms_map[9] = BS09; xsvf_tms_map[10] = BS10; xsvf_tms_map[11] = BS11; xsvf_tms_map[12] = BS12; xsvf_tms_map[13] = BS13; xsvf_tms_map[14] = BS14; xsvf_tms_map[15] = BS15; } #else { xsvf_clear(); xsvf->xsvf_tdo_mask = xsvf_tdo_mask; xsvf->xsvf_tdi = xsvf_tdi; xsvf->xsvf_tdo = xsvf_tdo; xsvf->xsvf_tdo_expected = xsvf_tdo_expected; xsvf->xsvf_address_mask = xsvf_address_mask; xsvf->xsvf_data_mask = xsvf_data_mask; } #endif xsvf->repeat = 32; xsvf->endir_state = XSTATE_RUN_TEST_IDLE; xsvf->enddr_state = STATE_RUN_TEST_IDLE; } static void xsvf_jtagtap_state_ack(uint8_t tms) { tms <<= 2; // either 0 or 4 xsvf->jtag_current_state = (xsvf_tms_transitions[xsvf->jtag_current_state] >> tms) & 0xf; } static void xsvf_jtagtap_shift_td( jtag_port_t* port, uint8_t *input_data, uint8_t *output_data, uint32_t data_bits, uint8_t must_end) { uint32_t i, j; uint32_t bit_count = data_bits; uint32_t byte_count = (data_bits+ 7) >> 3; for (i = 0; i < byte_count; ++i) { uint8_t byte_out = input_data[byte_count - 1 - i]; uint8_t tdo_byte = 0; for (j = 0; j < 8 && bit_count-- > 0; ++j) { uint8_t tdo; if (bit_count == 0 && must_end) { jtag_port_set_tms(port, 1); xsvf_jtagtap_state_ack(1); } jtag_port_set_tdi(port, byte_out & 1); byte_out >>= 1; tdo = jtag_port_pulse_clock_read_tdo(port); tdo_byte |= tdo << j; } output_data[byte_count - 1 - i] = tdo_byte; } } static void xsvf_jtagtap_state_step(jtag_port_t* port, uint8_t tms) { jtag_port_set_tms(port, tms); jtag_port_pulse_clock(port); xsvf_jtagtap_state_ack(tms); } static void xsvf_jtagtap_state_goto(jtag_port_t* port, uint8_t state) { if (xsvf->error) { return; } if (state == XSTATE_TEST_LOGIC_RESET) { uint8_t i; for (i = 0; i < 5; ++i) { xsvf_jtagtap_state_step(port, 1); } } else { while (xsvf->jtag_current_state != state) { xsvf_jtagtap_state_step(port, (xsvf_tms_map[xsvf->jtag_current_state] >> state) & 1); } } } static void xsvf_jtagtap_wait_time(jtag_port_t* port, uint32_t microseconds, uint8_t wait_clock) { uint32_t until; if (xsvf->error) { return; } until = micros() + microseconds; if (wait_clock) { while (microseconds--) { jtag_port_pulse_clock(port); } } while (micros() < until) { jtag_port_pulse_clock(port); } } static void xsvf_jtag_sir(jtag_port_t* port) { if (xsvf->error) { return; } xsvf_jtagtap_state_goto(port, XSTATE_SHIFT_IR); xsvf_jtagtap_shift_td(port, xsvf->xsvf_tdi, xsvf->xsvf_tdo, xsvf->sirsize_bits, 1); if (xsvf->runtest) { xsvf_jtagtap_state_goto(port, xsvf->endir_state); } else { xsvf_jtagtap_state_goto(port, XSTATE_RUN_TEST_IDLE); xsvf_jtagtap_wait_time(port, xsvf->runtest, 1); } } static uint8_t xsvf_jtag_is_tdo_as_expected(uint8_t use_mask) { uint32_t i; for (i = 0; i < xsvf->sdrsize_bytes; ++i) { uint8_t expected = xsvf->xsvf_tdo_expected[i]; uint8_t actual = xsvf->xsvf_tdo[i]; if (use_mask) { uint8_t mask = xsvf->xsvf_tdo_mask[i]; expected &= mask; actual &= mask; } #if XSVF_IGNORE_NOMATCH != 1 if (expected != actual) { #if XSVF_DEBUG Serial.println(F("D...NO MATCH!")); #endif return 0; } #endif } #if XSVF_DEBUG Serial.println(F("D...match!")); #endif return 1; } #define SDR_MUST_BEGIN (flags & 0b1000) #define SDR_MUST_CHECK (flags & 0b0100) #define SDR_USE_MASK (flags & 0b0010) #define SDR_MUST_END (flags & 0b0001) static uint8_t xsvf_jtag_sdr(jtag_port_t* port, uint8_t flags) { int16_t attempts_left = xsvf->repeat; uint8_t matched = 0; uint8_t must_end = SDR_MUST_END; uint8_t must_check = SDR_MUST_CHECK; uint8_t use_mask = SDR_USE_MASK; if (xsvf->error) { return 0; } if (SDR_MUST_BEGIN) { xsvf_jtagtap_state_goto(port, XSTATE_SHIFT_DR); } while (!matched && attempts_left-- >= 0) { xsvf_jtagtap_shift_td(port, xsvf->xsvf_tdi, xsvf->xsvf_tdo, xsvf->sdrsize_bits, must_end); if (!must_check) { break; } matched = xsvf_jtag_is_tdo_as_expected(use_mask); if (!matched) { // XAP058, page 14 xsvf_jtagtap_state_goto(port, XSTATE_PAUSE_DR); xsvf_jtagtap_state_goto(port, XSTATE_SHIFT_DR); xsvf_jtagtap_state_goto(port, XSTATE_RUN_TEST_IDLE); xsvf_jtagtap_wait_time(port, xsvf->runtest, 1); // xsvf_jtagtap_state_goto(port, XSTATE_SHIFT_DR); #if XSVF_DEBUG if (attempts_left >= 0) { Serial.print(F("D...repeating: ")); Serial.println(xsvf->repeat - attempts_left, DEC); } #endif } } if (must_check && !matched) { xsvf->error = ERR_DR_CHECK_FAILED; Serial.println(F("D!DR check failed!")); } if (must_end && matched) { if (!xsvf->runtest) { xsvf_jtagtap_state_goto(port, xsvf->enddr_state); } else { xsvf_jtagtap_state_goto(port, XSTATE_RUN_TEST_IDLE); xsvf_jtagtap_wait_time(port, xsvf->runtest, 1); } } return !must_check || (must_check && matched); } /* * Reads the next instruction from the serial port. Also reads any * remaining instruction parameters into the instruction buffer. */ static uint8_t xsvf_player_handle_next_instruction(jtag_port_t* port) { uint8_t instruction = xsvf_player_next_byte(); if (xsvf->error) { return ERR_IO; // failure } xsvf->instruction_counter++; #if XSVF_DEBUG Serial.print(F("D INSTR ")); Serial.print(xsvf->instruction_counter, DEC); Serial.print(F(" (0x")); Serial.print(instruction, HEX); Serial.print(F("): ")); #endif //do not use switch as it uses RAM // ---[COMPLETE ] -------------------------------------------- if (instruction == XCOMPLETE) { #if XSVF_DEBUG Serial.println(F("XCOMPLETE")); #endif xsvf->xcomplete = 1; } else // ---[TDO MASK] -------------------------------------------- if (instruction == XTDOMASK) { #if XSVF_DEBUG Serial.println(F("XTDOMASK")); #endif xsvf_player_get_next_bytes(xsvf->xsvf_tdo_mask, xsvf->sdrsize_bytes); } else // ---[SIR SIR2] -------------------------------------------- if (instruction == XSIR || instruction == XSIR2) { #if XSVF_DEBUG Serial.println(instruction == XSIR ? F("XSIR") : F("XSIR2")); #endif xsvf->sirsize_bits = xsvf_player_get_next_byte(); if (instruction == XSIR2) { xsvf->sirsize_bits <= 8; xsvf->sirsize_bits |= xsvf_player_get_next_byte(); } xsvf->sirsize_bytes = (xsvf->sirsize_bits + 7) >> 3; if (xsvf->sirsize_bytes > S_MAX_CHAIN_SIZE_BYTES) { return ERR_XSIR_SIZE; } xsvf_player_get_next_bytes(xsvf->xsvf_tdi, xsvf->sirsize_bytes); xsvf_jtag_sir(port); } else // ---[SDR ] -------------------------------------------- if (instruction == XSDR || (instruction >= XSDRB && instruction <= XSDRE)) { uint8_t flags = 0b1111; #if XSVF_DEBUG Serial.println(F("XSDRx")); #endif xsvf_player_get_next_bytes(xsvf->xsvf_tdi, xsvf->sdrsize_bytes); if (instruction != XSDR) { flags = (instruction == XSDRB) ? 0b1000 : (instruction == XSDRC) ? 0b0000 : 0b0001; } if (!xsvf_jtag_sdr(port, flags)) { xsvf->error = ERR_XSDR; } } else // ---[RUN TEST ] -------------------------------------------- if (instruction == XRUNTEST) { #if XSVF_DEBUG Serial.println(F("XRUNTEST")); #endif xsvf->runtest = xsvf_player_get_next_long(); } else // ---[REPEAT ] -------------------------------------------- if (instruction == XREPEAT) { #if XSVF_DEBUG Serial.println(F("XREPEAT")); #endif xsvf->repeat = xsvf_player_get_next_byte(); } else // ---[SDRSIZE ] -------------------------------------------- if (instruction == XSDRSIZE) { #if XSVF_DEBUG Serial.println(F("XSDRSIZE")); #endif xsvf->sdrsize_bits = xsvf_player_get_next_long(); xsvf->sdrsize_bytes = (xsvf->sdrsize_bits + 7) >> 3; if (xsvf->sdrsize_bytes > S_MAX_CHAIN_SIZE_BYTES) { return ERR_XSDRSIZE; } } else // ---[SDRTDO ] -------------------------------------------- if (instruction == XSDRTDO || (instruction >= XSDRTDOB && instruction <= XSDRTDOE)) { uint8_t flags = 0b1111; #if XSVF_DEBUG Serial.println(F("XSDRTDOx")); #endif xsvf_player_get_next_bytes(xsvf->xsvf_tdi, xsvf->sdrsize_bytes); xsvf_player_get_next_bytes(xsvf->xsvf_tdo_expected, xsvf->sdrsize_bytes); if (instruction != XSDRTDO) { flags = (instruction == XSDRTDOB) ? 0b1100 : (instruction == XSDRTDOC) ? 0b0100 : 0b0101; } if (!xsvf_jtag_sdr(port, flags)) { xsvf->error = ERR_XSDR; } } else // ---[SET SDR MASKS ] -------------------------------------------- if (instruction == XSETSDRMASKS) { #if XSVF_DEBUG Serial.println(F("XSETSDRMASKS")); #endif xsvf_player_get_next_bytes(xsvf->xsvf_address_mask, xsvf->sdrsize_bytes); xsvf_player_get_next_bytes(xsvf->xsvf_data_mask, xsvf->sdrsize_bytes); } else // ---[SDR INC ] -------------------------------------------- if (instruction == XSDRINC) { #if XSVF_DEBUG Serial.println(F("XSDRINC")); #endif xsvf_player_get_next_bytes(xsvf->xsvf_tdi, xsvf->sdrsize_bytes); // TODO - check: return false? } else // ---[STATE ] -------------------------------------------- if (instruction == XSTATE) { #if XSVF_DEBUG Serial.println(F("XSTATE")); #endif xsvf->next_state = xsvf_player_get_next_byte(); xsvf_jtagtap_state_goto(port, xsvf->next_state); } else // ---[END IR ] -------------------------------------------- if (instruction == XENDIR) { uint8_t s; #if XSVF_DEBUG Serial.println(F("XENDIR")); #endif s = xsvf_player_get_next_byte(); if (s == 0) { xsvf->endir_state = STATE_RUN_TEST_IDLE; } else if (s == 1) { xsvf->endir_state = STATE_PAUSE_IR; } else { return ERR_XENDIR; } } else // ---[END DR ] -------------------------------------------- if (instruction == XENDDR) { uint8_t s; #if XSVF_DEBUG Serial.println(F("XENDDR")); #endif s = xsvf_player_get_next_byte(); if (s == 0) { xsvf->enddr_state = STATE_RUN_TEST_IDLE; } else if (s == 1) { xsvf->enddr_state = STATE_PAUSE_DR; } else { return ERR_XENDDR; } } else // ---[COMMENT ] -------------------------------------------- if (instruction == XCOMMENT) { uint8_t c; #if XSVF_DEBUG Serial.println(F("XCOMMENT")); #endif Serial.print(F("D"));//debug message preamble //read the comment bytes do { c = xsvf_player_get_next_byte(); // special feature: dump the TDO data if (c == '#') { uint8_t cnt = 0; uint8_t size = xsvf_player_get_next_byte() - '0'; //dump the tdo buffer bytes while(cnt < size) { char t[4]; uint8_t v = xsvf->xsvf_tdo[cnt]; uint8_t x1 = v >> 4; v &= 0xF; // DEC to HEX conversion with leading zero t[0] = (char) (x1 < 10 ? '0' + x1 : 55 + x1 ); t[1] = (char) (v < 10 ? '0' + v : 55 + v ); t[2] = 0; Serial.print(t); cnt++; } } else if (c) { Serial.print((char)c); } } while(c); Serial.println(); } else // ---[WAIT ] -------------------------------------------- if (instruction == XWAIT || instruction == XWAITSTATE) { uint32_t clock_cnt = 0; uint8_t wait_clock = 1; #if XSVF_DEBUG Serial.println(instruction == XWAIT ? F("XWAIT") : F("XWAITSTATE")); #endif //TOOD - do we need these states to be global? xsvf->wait_start_state = xsvf_player_get_next_byte(); xsvf->wait_end_state = xsvf_player_get_next_byte(); if (instruction == XWAITSTATE) { clock_cnt = xsvf_player_get_next_long(); wait_clock = clock_cnt > 0 ? 1 : 0; } #if XSVF_DEBUG Serial.print(F("Dclock:")); Serial.println(clock_cnt, DEC); #endif xsvf->wait_time_usecs = xsvf_player_get_next_long(); #if XSVF_DEBUG Serial.print(F("Dmicros:")); Serial.println( xsvf->wait_time_usecs, DEC); #endif xsvf_jtagtap_state_goto(port, xsvf->wait_start_state); // happens only during XWAITSTATE while (clock_cnt) { jtag_port_pulse_clock(port); clock_cnt--; } xsvf_jtagtap_wait_time(port, xsvf->wait_time_usecs, wait_clock); xsvf_jtagtap_state_goto(port, xsvf->wait_end_state); } else // ---[TRST - test line reset] -------------------------------------------- if (instruction == XTRST) { #if XSVF_DEBUG Serial.println(F("XTRST")); #endif //read test reset mode (0-on, 1-off, 2-Z, 3-Absent) xsvf_player_get_next_byte(); } else // ---[UNKNOWN ] -------------------------------------------- { #if XSVF_DEBUG Serial.print(F("XUNKNOWN:")); Serial.println(instruction, DEC); #endif //unimplemented instruction return ERR_INSTR_NOT_IMPLEMENTED; } if (xsvf->error) { return xsvf->error; // failure } return 0; } static void jtag_play_xsvf(jtag_port_t* port) { uint32_t n = 0; uint8_t ret; xsvf_player_init(port); //check xref is high if (!jtag_port_get_veref(port)) { Serial.println(F("Q-255,JTAG not connected")); return; } Serial.println(F("RXSVF")); //announce ready to receive XSVF stream while(1) { n++; ret = xsvf_player_handle_next_instruction(port); if (ret) { Serial.print(F("Q-")); Serial.print(ret, DEC ); Serial.println(F(",Fail")); break; } else { if (xsvf->xcomplete) { Serial.println(F("!Success")); break; } } } Serial.print(F("!Processed instr:")); Serial.println(xsvf->instruction_counter, DEC); #if XSVF_CALC_CSUM Serial.print(F("!sum: 0x")); // print leading zeros in the check sum hex value { uint32_t i = 0xF0000000; while((!(xsvf->csum & i)) && i) { Serial.print(F("0")); i >>= 4; } } Serial.print(xsvf->csum, HEX); Serial.print(F("/")); Serial.println(xsvf->rdpos, DEC); #endif /* XSVF_CALC_CSUM */ if (xsvf->xcomplete) { Serial.println(F("Q-0,OK")); } //the 3 pins must be low or else the vref might be triggered next time digitalWrite(port->tms, 0); digitalWrite(port->tdi, 0); digitalWrite(port->tck, 0); delay(100); // put the jtag port pins into High-Z (vref already is input) pinMode(port->tms, INPUT); pinMode(port->tdi, INPUT); pinMode(port->tck, INPUT); pinMode(port->tdo, INPUT); } #endif /*_JTAG_XSVF_PLAYER_H_*/